Contents
1. Intersection AlgorithmsGPU implicit signed distance
2. Marching
3. Distance Estimators
4. Sphere Tracing
5. Some Distance Estimators
- Sphere
- Plane
- Box
- Rounded Box
- Torus
- Wheel
- Cylinder
6. Computing Normals
7. A Simple GLSL Ray Caster
- C++ Shader Launch
- GLSL Ray Setup
- GLSL Intersection
8. Operations on Distance Estimators
9. Some Useful Operators
- Union
- Intersection
- Subtraction
- Repetition
- Transformation
- Blending
10. Increasing Performance
- Over-Relaxation
- Bounding Spheres
- Reintroducing Analytic Roots
- Other Optimization Strategies
11. Some Online Examples in GLSL
- Educational
- Aspirational
12. Further Reading

Ray marching is an alternative to analytic methods for discovering intersections between a light transport ray and the scene. The structure of the ray marching algorithm makes it amenable to rendering scenes constructed from operations on solid objects, amorphous surfaces, and participating media, which have no explicit surface.

Analytic intersection is extremely efficient. Renderers based on it can render simple scenes interactively on a CPU, which is great for learning and experimentation. Ray marching is less efficient. So, this chapter also introduces Graphics Processing Unit (GPU) programming to enable you to build a real-time ray marching renderer.

© 2014 Morgan McGuire
A reference scene defined by implicit surfaces ray traced at 60fps on
GeForce 650M using the techniques described in this document.
© 2013 Pablo Roman Andrioli
An impressive open source demo of real-time ray-traced implicit surface fractals
by Kali (Pablo Roman Andrioli), implemented in about 300 lines of GLSL.

1. Intersection AlgorithmsGPU implicit signed distance

Most computational graphics rendering methods are based on ray-surface intersection. The three major ray-surface algorithms are:

  • Analytic ray intersection
  • Numerical intersection by ray marching
  • Rasterization with a depth buffer

Analytic ray intersection and ray marching use implicit surface definitions. For example, the unit-meter sphere is implicitly defined by the set of points satisfying

{XR3m | g(X)=0m}(1)

h(XR3m)=|X|1m.(2)
That is, the zero-crossing of the function hR3mRm measuring signed distance from the surface of the sphere.

Analytic ray-surface intersection gives a closed-form solution by solving for the distance parameter t for which the explicit equation of a ray,

X(tRm)=PR3m+ω^S2t(3)
satisfies the implicit equation of the scene, in this case, a sphere. While analytic solutions exist for some cases, such as ray-sphere and ray-triangle intersection, there is no general analytic solution possible for arbitrary ray-surface intersection.

Ray marching is an algorithm for numerical estimation of arbitrary ray-surface intersections. It works for arbitrary implicit surfaces (although most of the optimizations that make it practical for real-time use require a surface definition with certain properties).

The simplest form of ray marching begins at the ray origin and samples the implicit surface at regular intervals, terminating when the function crosses zero. This is of course both slow and innaccurate. Fortunately, any numerical root-finding strategy, such as the secant method or Newton-Raphson iteration, can be employed to accelerate it or improve its accuracy. For example, choosing the step size between successive samples based on the derivative of the surface gives faster convergence and more accuracy. Binary search near the zero crossing is a good way to identify the intersection with arbitrary accuracy for continuous implicit surface definitions.

Rasterization with a depth buffer is an amortization of analytic ray intersection over many rays that relies on both explicit and implicit surface definitions. It processes many rays for each surface, instead of many surfaces for each ray. Because of this, it relies on an auxillary image-space structure called the depth buffer to keep track of the currently-known closest surface location to the camera at each image sample. (There are also rasterization methods that perform sophisticated clipping of primitives against each other to avoid this structure, however their increased run time cost puts them out of favor today.)

Rasterization is extremely efficient for triangle meshes on massively parallel hardware, and algorithms are known for some other primitives such as lines, rectangles, and disks. However, because it requires both analytic implicit and explicit equations, rasterization is highly constrained to such primitives.

2. Marching

Consider an example of solving for the root of the equation that gives the intersection of a ray P+ω^t and a general sphere with center point C and radius r,

g(tRm)=||P+ω^tC||r=0m.(4)

The simplest implementation of ray marching iterates t through the domain of function g in fixed Δt steps:

  1. 1def findRootNaive(gRmRm)Rm:
  2. 2 ΔtRm=0.01m
  3. 3 tRm=0m
  4. 4 while g(t)0m:
  5. 5 t=t+Δt
  6. 6 return t

This marches through every point X(t)=P+ω^t on the ray until it finds a t that yields an X on the surface of the sphere.

Of course, this naive ray marching scheme is unlikely to exactly land on the exact value of t for which g(t)=0m, so the code will almost always loop forever. A better solution enforces a maximum distance bound and seeks the first value at which g crosses from positive to nonpositive, at which point the ray must have passed through the surface:

  1. 1def findRoot(gRmRm, maxDistanceRm)Rm:
  2. 2 ΔtRm=0.01m
  3. 3 tRm=0m
  4. 4 while (t < maxDistance) and (g(t)>0m):
  5. 5 t=t+Δt
  6. 6 return t

We can further refine this approach using binary search within the final fixed interval [tn1,tn] in which g crossed from positive to nonpositive values.

Ray marching with fixed steps has three advantages over analytic ray intersections:

  • Very simple to implement
  • Works for any implicitly defined surface
  • Naturally extends to integration of scattering in participating media, such as fog

Ray marching with fixed steps has two obvious disadvantages over analytic ray tracing. The first is that it can miss the intersection for a non-convex shape. The second is that it takes at least linear time in the distance to the intersection for rays that do intersect the surface and linear time in maxDistance for rays that do not intersect. Analytic ray tracing is guaranteed to not only find the intersection, but do it in constant time.

We can mitigate both the performance disadvantage and the missed intersection disadvantage of fixed-step ray marching with a simple improvement that only slightly constrains the surface description.

3. Distance Estimators

We originally defined g(t)=h(P+ω^t)=0m as the surface. The ray marching algorithm implicitly required only that g(t)>0m at the ray origin P and g was continuous. Now, let us require the surface to be an embedded manifold without boundary, i.e., the surface of a solid object, and refine our constraints so that g and h are signed distance estimators: require that g(t)=h(P+ω^t) is less than or equal to than the true distance to the surface from point X(t)=P+ω^t.

Because we're working with surfaces in three dimensions and will wish to cast rays from many different origins (e.g., primary rays, shadow rays, mirror rays), it will be convenient to define a distance estimator on three-space instead of the ray parameter.

We now formally define function h(X)=g(P+ω^t) be a signed distance estimator for a surface. For the sphere, one function that satisfies this is simply the original implicit equation: hsphere(X)=||XC||r.

The h(X)=0m surface is sometimes called the isosurface, although technically it is the h=0m isosurface. Fluids are often modeled with a large number of particles, which are collectively rendered by forming a single distance estimator that is the sum of a large number of so-called blobby distance estimators. In this case, the term level set is sometimes used to describe the surface.

4. Sphere Tracing

Given a signed distance estimator, h(X), we now have an upper bound on how far is safe to step to avoid marching the ray over the intersection. Because h returns a bound on the distance in any direction, we can move at least that far along the direction ω^ of the ray. In other words, if we consider a sphere of radius h(X) of possible locations to visit from point X, that sphere at most touches (i.e., is tangent to) the primitive (...which is also a sphere in our example) that we're tracing against, and may not even touch it.

That new virtual sphere of possible locations to visit can't possibly intersect the primitive more deeply because of the distance estimator guarantee. So, we can jump to testing the next point at the surface of the virtual sphere. This method for advancing the ray is called sphere tracing [Hart1996Sphere] . Note that the sphere in the name refers to the sphere within which the algorithm can safely march from its current location; the method can trace any primitive, and intersects the primitives with rays, not spheres.

  1. 1def sphereTrace(PR3m,wS2,hR3mRm,maxDistanceRm)Rm:
  2. # How close we want to get to the surface
  3. 2 ϵRm=0.0000001m
  4. # Enforce this minimum step through space
  5. 3 minStep  Rm = 0.0001m
  6. 4 tRm=0m
  7. 5 ΔtRm=h(P+ω^t)
  8. 6 while (t < maxDistance) and (Δt > ϵ):
  9. 7 t=t+max(Δt,minStep)
  10. 8 Δt=h(P+ω^t)
  11. 9 return t

Why is iteration necessary? Doesn't h give the distance to the surface immediately? If h gave the exact distance to the surface, then the while loop would be unnecessary. However, recall that h is a conservative estimate of the distance. If the surface is 1m from a point X, then h(X) might return 0.1m. So, we must iterate until h(X) converges to zero, or at least very nearly so.

The minStep constant is necessary to ensure that the ray continues to advance even when asymptotically approaching a surface. It is particularly important for achieving reasonable performance in the face of an overly conservative distance estimator or at locations where the ray just barely passes by the surface. One could additionally impose an explicit iteration limit independent of the minimum step size. Keinert et al. [2014] recommend tracking and returning t corresponding to the closest point ever found to the ray instead of the marching end point when terminating after a fixed number of iterations.

As before, we can extend this root finding method to perform binary search to refine the end hit point. Because h is a signed distance estimator, we can even do so fairly efficiently. Once the ray passes through the surface we can re-approach it accurately from the inside.

5. Some Distance Estimators

For these definitions, let max(v⃗ )=max(xv,yv,zv), |v⃗ |=(|xv|,|yv|,|zv|), and let max(a⃗ ,b⃗ )=(max(xa,xb),max(ya,yb),max(za,zb)). The code samples are in GLSL using some common utilities and HLSL compatibility definitions:

Copy
  1. 1#define Vector2 vec2
  2. 2#define Point3 vec3
  3. 3#define Vector3 vec3
  4. 4#define lerp mix
  5. 5float maxComponent(vec3 v) { return max(v.x, max(v.y, v.z)); }
  6. 6float saturate(float x) { return clamp(x, 0.0, 1.0); }

Sphere

The sphere about point C with radius r:

Math
GLSL
h(X)=XCr(5)
Copy
  1. 1float sphereDistance(Point3 X, Point3 C, float r) {
  2. 2 return length(X - C) - r;
  3. 3}

Plane

The plane with point C and normal n^:

Math
GLSL
h(X)=(XC)n^(6)
Copy
  1. 1float planeDistance(Point3 X, Point3 C, Vector3 n) {
  2. 2 return dot(X - C, r);
  3. 3}

Box

The box with center C and vector b⃗  from the center to the first-quadrant corner:

Math
GLSL
Let d⃗ =|XC|b⃗ 
h(X)=min(max(d),0)+max(d,(0,0,0))(7)
Copy
  1. 1float boxDistance(Point3 X, Vector3 b) {
  2. 2 Vector3 d = abs(X - C) - b;
  3. 3 return min(maxComponent(d), 0) + length(max(d, Vector3(0, 0, 0)));
  4. 4}

Rounded Box

The hollow rounded box with center C, edge half-lengths in vector b⃗ , and rounding radius r:

Math
GLSL
h(X)=max(|XC|b⃗ ,(0,0,0))r(8)
Copy
  1. 1float roundedBoxDistance(Point3 X, Vector3 b, float r) {
  2. 2 return length(max(abs(X - C) - b, Vector3(0, 0, 0))) - r;
  3. 3}

Torus

The torus about the x-axis with centroid C, minor radius r, and major radius R:

Math
GLSL
h(X)=((xXxC)2+(zXzC)2R,yXyC)r(9)
Copy
  1. 1float torusDistance(Point3 X, Point3 C, float R, float r) {
  2. 2 return length(vec2(length(X.xz - C.xz) - R, X.y - C.y)) - r;
  3. 3}

Wheel

The wheel about the x-axis with centroid C, minor radius r, and major radius R is the same as the torus above, but with a non-Euclidean definition of distance:

Math
GLSL
h(X)=((xXxC)2+(zXzC)2R,yXyC)8r(10)
Here, v⃗ n is the n-norm: xnv+ynv+znvn. Higher-order norms like this can be substituted into most distance estimators to square off edges; compare the wheel on the right to the torus above it.
Copy
  1. // x^8
  2. 1float pow8(float x) {
  3. 2 x *= x; // x^2
  4. 3 x *= x; // x^4
  5. 4 return x * x; // x^8
  6. 5}
  7. // The L8-norm, ||v||_8
  8. 6float length8(Vector2 v) {
  9. 7 return pow(pow8(v.x) + pow8(v.y), 1.0);
  10. 8}
  11. 9float wheelDistance(Point3 X, Point3 C, float R, float r) {
  12. 10 return length8(Vector2(length(X.xz - C.xz) - r, X.y - C.y)) - R;
  13. 11}

Cylinder

The cylinder with centroid C, radius r, and half-height e:

Math
GLSL
Let d⃗ =((xXxC)2+(zXzC)2r,yXyC)(r,e)
h(X)=min(max(xd,yd),0)+max(d⃗ ,(0,0))(11)
Copy
  1. 1float cylinderDistance(Point3 X, Point3 C, float r, float e) {
  2. 2 Vector2 d = abs(Vector2(length(X.xz - C.xz), X.y - C.y)) - Vector2(r, e);
  3. 3 return min(maxComponent(d), 0) + length(max(d, Vector2(0, 0)));
  4. 4}

6. Computing Normals

The gradient of any function on 3-space can be approximated by numerical differentiation:

h(X)=(h(X)x,h(X)y,h(X)z)

12ϵ(h(X+x^ϵ)h(Xx^ϵ),h(X+y^ϵ)h(Xy^ϵ),h(X+z^ϵ)h(Xz^ϵ))

1ϵ[(h(X+x^ϵ),h(X+y^ϵ),h(X+z^ϵ))h(X)(1,1,1)](12)

If the distance estimator is not too conservative near the surface, or at least is conservative by the same factor in all directions, we can use this to find the surface normal.

For a point X that is near but not on the surface, normalizing the gradient by dividing through by its length gives the surface normal vector to the nearby surface.

Placing X exactly on the surface can be problematic for this computation, however. For example, for a sufficiently curvy surface, a particular ϵ value chosen may place all samples of h at another location on the surface, for which h=0m.

Reasonable four- and six-sample approximations of the normal are thus:

Copy
  1. 1Vector3 fastNormal(Point3 X) {
  2. 2 const float e = 1e-4;
  3. 3 float d = sceneDistance(X);
  4. 4 return normalize(Vector3(
  5. 5 sceneDistance(X + Vector3(e, 0, 0)),
  6. 6 sceneDistance(X + Vector3(0, e, 0)),
  7. 7 sceneDistance(X + Vector3(0, 0, e))) - Vector3(d, d, d));
  8. 8}
  9. 9Vector3 normal(Point3 X) {
  10. 10 const float e = 1e-4;
  11. 11 const Vector3 u = Vector3(e, 0, 0);
  12. 12 const Vector3 v = Vector3(0, e, 0);
  13. 13 const Vector3 w = Vector3(e, 0, e);
  14. 14 return normalize(Vector3(
  15. 15 sceneDistance(X + u) - sceneDistance(X - u),
  16. 16 sceneDistance(X + v) - sceneDistance(X - v),
  17. 17 sceneDistance(X + w) - sceneDistance(X - w)));
  18. 18}

7. A Simple GLSL Ray Caster

This section describes the ray casting portion of a simple GLSL ray marching tracer that runs on the GPU using the G3D Innovation Engine 10. See http://codeheartjs.com/examples/raytrace/ for a comparable CPU Javascript version that runs in a web browser, and http://codeheartjs.com/examples/fastraytrace/ for an optimized Javascript version. See my gpu-tracing-tutorial.zip for a working example of an analytic ray tracer in C++ and GLSL against which to compare this ray marcher's structure. You can inject the ray marcher directly into that program structure as well.

C++ Shader Launch

The GLSL ray marcher below uses rasterization to submit two giant triangles that cover the entire viewport, under a 2D projection matrix. It then launches the ray tracing shader kernel at each pixel, passing it the 3D camera's orientation and projection matrix. The C++ syntax for setting up this call in OpenGL (from App::onGraphics3D) is:

Copy
  1. 1rd->push2D();
  2. 2Args args;
  3. 3args.setUniform("cameraToWorldMatrix", activeCamera()->frame());
  4. 4args.setUniform("tanHalfFieldOfViewY",
  5. 5 float(tan(activeCamera()->projection().fieldOfViewAngle() / 2.0f)));
  6. // Projection matrix, for writing to the depth buffer.
  7. 6Matrix4 projectionMatrix;
  8. 7activeCamera()->getProjectUnitMatrix(rd->viewport(), projectionMatrix);
  9. 8args.setUniform("projectionMatrix22", projectionMatrix[2][2]);
  10. 9args.setUniform("projectionMatrix23", projectionMatrix[2][3]);
  11. 10// A cube map Texture
  12. 11m_skybox->setShaderArgs(args, "skybox.", Sampler::cubeMap());
  13. 12// Set the domain of the shader to the viewport rectangle
  14. 13args.setRect(rd->viewport());
  15. 14LAUNCH_SHADER("trace.pix", args);
  16. 15rd->pop2D();

GLSL Ray Setup

The GLSL code within the referenced trace.pix shader sets up the primary ray and then marches it through the scene. I've also rigged it to write a depth buffer value that is compatible with rasterization so that rasterized and ray traced primitives may be mixed in the frame buffer. Furthermore, this enables the use of standard post-processing tricks such as single-image depth of field, or even depth-buffer based ambient occlusion as a post process.

Copy
  1. 1#version 410 // -*- c++ -*-
  2. 2#include <g3dmath.glsl>
  3. 3#include <Texture/Texture.glsl>
  4. // Input arguments from the C++ program
  5. 4uniform mat4x3 cameraToWorldMatrix;
  6. 5uniform float tanHalfFieldOfViewY;
  7. 6uniform float projectionMatrix22, projectionMatrix23;
  8. 7uniform TextureCube skybox;
  9. // Output to the App::m_framebuffer (assume post-processed tonemap and gamma encoding)
  10. 8out Radiance3 pixelRadiance;
  11. 9void main() {
  12. // Generate an eye ray in camera space, and then transform to world space
  13. // Primary ray origin
  14. 10 Point3 P = cameraToWorldMatrix[3];
  15. // Primary ray direction
  16. 11 Vector3 w = Matrix3(cameraToWorldMatrix) *
  17. 12 normalize(Vector3((gl_FragCoord.xy - g3d_FragCoordExtent / 2.0) *
  18. 13 Vector2(1, -1), g3d_FragCoordExtent.y /
  19. 14 ( -2.0 * tanHalfFieldOfViewY)));
  20. 15 float distance = inf;
  21. 16 pixelRadiance = traceRay(P, w, distance);
  22. // Camera space z value
  23. 17 float csZ = maxDist / w.z;
  24. // Pack into standard OpenGL depth buffer format to make the result
  25. // compatible with rasterization and post-processing.
  26. 18 gl_FragDepth = (maxDist == inf) ? 1.0 :
  27. 19 ((projectionMatrix22 * csZ + projectionMatrix23) / -csZ);
  28. 20}

GLSL Intersection

© 2013 Morgan McGuire
The result of the simple
GLSL ray marcher.

The actual tracing code is below. This example defines the scene to be a single, yellow sphere at the origin with a radius of 1m. To make it easier to orient the viewer when investigating the scene with the default camera, I also placed a cube map skybox in the background.

For a full ray tracer, we'd shade the intersection ray and possibly spawn additional rays for reflection, refraction, and shadows.

Copy
  1. 1float sceneDistance(Point3 X) {
  2. 2 const Point3 C = Point3(0,0,0);
  3. 3 const float r = 1.0;
  4. 4 return length(X - C) - r;
  5. 5}
  6. // Trace the ray P + w * t.
  7. // Returns true if something was hit.
  8. // Sets L_o if the ray reached infinity or if it hit something before distance
  9. // If something was hit, updates distance
  10. 6bool traceRay(Point3 P, Vector3 w, out L_o, inout float distance) {
  11. 7 const float maxDistance = 1e10;
  12. 8 const int maxIterations = 50;
  13. 9 const float closeEnough = 1e-2;
  14. 10 float t = 0;
  15. 11 for (int i = 0; i < maxIterations; ++i) {
  16. 12 float dt = sceneDistance(P + w * t);
  17. 13 t += dt;
  18. 14 if (dt < closeEnough) {
  19. 15 distance = t;
  20. 16 L_o = Radiance3(1, 1, 0);
  21. 17 return true;
  22. 18 } else if (t > distance) {
  23. // Too far; there is some known closer intersection
  24. 19 return false;
  25. 20 }
  26. 21 }
  27. // Reached infinity
  28. 22 L_o = texture(skybox.sampler, w).rgb * skybox.readMultiplyFirst.rgb;
  29. 23 return false;
  30. 24}

This setup of using minimal OpenGL to launch a full-screen ray marcher is common in the modern demoscene. Many examples of artistically impressive demos and intros based around this technique can be found at pouet.net. Smaller single-shader examples with source code can be found at shadertoy.com and glslsandbox.com.

8. Operations on Distance Estimators

An advantage of modeling surfaces with distance estimators is that it is much easier to perform operations on whole shapes in that model than it is when they have explicit triangle representations or direct implicit definitions.

Operators on distance estimators are higher-order functions: they take functions as input and return functions as output. In a language such as Javascript or Scheme that has full support for closures, this can be implemented directly with functions. (As was done in the http://codeheartjs.com/examples/raytrace example from the previous section, which runs in a web browser.)

In a language such as Java or C++, classes and inheritance can mimic the design pattern. A simple substitution-compiled language like GLSL with provides none of these language features for abstracting computation. They can be emulated using macros and overloading or one can directly expand that code by hand, for example,

Copy
  1. 1float unionDistance(float d1, float d2) { return min(d1, d2); }
  2. 2float twoSphere(Point3 X) {
  3. 3 return unionDistance(sphereDistance(X, Point3(-1, 0, 0), 1),
  4. 4 sphereDistance(X, Point3( 1, 0, 0), 1));
  5. 5}

9. Some Useful Operators

Union

Union selects the closer of two surfaces. This is equivalent to a set sum on the points (but not a distance sum of the estimators).

Math
GLSL
(hf)(X)=min(h(X),f(X))(13)
Copy
  1. 1#define surfaceUnion(h, f, X) min(h(X), f(X))

Intersection

Intersection selects the farther of two surfaces.

Math
GLSL
(hf)(X)=max(h(X),f(X))(14)
Copy
  1. 1#define intersectSurface(h, f, X) max(h(X), f(X))

Subtraction

The set difference (subtraction) of two surfaces turns one inside out and then intersects its outside it with the other's inside.

Math
GLSL
(hf)(X)=max(h(X),f(X))(15)
Copy
  1. 1#define subtractSurface(h, f, X) max(h(X), -f(X))

Repetition

Any distance function can be tiled across space with period v⃗  across the dimensions.

Math
GLSL
repeat(h,p⃗ )(X)=h((X mod v⃗ )v⃗ /2)(16)
Copy
  1. 1#define repeat(h, period, X) h(mod(X, period))
Note that floating-point modulo in GLSL is notated with the mod function, not the % operator as in C++.

Transformation

Transforming a shape is equivalent (from the reference frame of the distance estimator) to inversely transforming the points tested against it. In doing so, we need to be careful about how we have scaled space, however. To transform a shape by an invertible 4×4 rotation-translation-dilation (dilation means a uniform scale along all axes) matrix M,

Math
GLSL
(Mh)(X)=h(M1X)detM(17)
,
where the expression on the right is the determinant M.
Copy
  1. 1#define transformSurface(h, M, X)\
  2. 2 h((inverse(M) * vec4(X, 1.0)).xyz) * determinant(M)
In practice, this is inefficient unless M is known at compile time or the inverse and determinant are explicitly passed as uniform arguments.

Because rotation, translation, and non-zero dilation all have trivial inverses and determinants it is not usually necessary to apply the full inverse and determinant operations. For example scaling a primitive by scalar factor s>0 is simply:

Math
GLSL
scale(hR3mRm,sR)(X)=h(X/s)s(18)
.
Copy
  1. 1#define scaleSurface(h, s, X) (h(X / (s)) * (s))

Note that if a transformation of a simple primitive is desired, it may be more efficient to let C=(0,0,0) in the original primitive's definition so that it is centered at the origin and then perform a single transformation to the desired reference frame.

Blending

With some care to preserve the conservative property of distance estimation, shapes can be blended for a kind of smooth union. Hoffman and Hopcroft [1985] derive the general case of this, which is commonly referred to as a union using a smooth min (smin) function in place of a typical min function.

There are many smin functions, with a variety of performance and quality tradeoffs. Iñigo Quilez [2008] and I recommend this fast polynomial version:

Copy
  1. 1float smin(float a, float b, float blendRadius) {
  2. 2 float c = saturate(0.5 + (b - a) * (0.5 / blendRadius));
  3. 3 return lerp(b, a, c) - blendRadius * c * (1.0 - c);
  4. 4}

10. Increasing Performance

Performance is always a concern in rendering. The performance of ray marching can be increased at the cost of image quality by increasing the minimum step size and accepted distance from the surface, and by decreasing the maximum iterations permitted and resolution. However, it can also be increased by algorithmic improvements that do not affect image quality. Instead, the cost is some of the elegant simplicity of the naive method. However, compared to analytic ray casting and rasterization, optimized ray marching remains remarkably straightforward and accessible to implement.

Over-Relaxation

Keinert et al. [2014] make an observation that allows decreasing the number of iterations before binary search by up to a factor of two. Hart's sphere tracing uses the distance estimator h to create a series of unbounding spheres as the ray approaches a surface. The h(X)=0m isosurface cannot lie within any of these spheres. Therefore, if the unbounding spheres at X and Y overlap, the surface cannot intersect the line segment XY.

This observation allows speculatively advancing the ray by Δt=kh(X) for 1k2 under the following process. Let the new point be Y=X+ω^Δt. If h(Y)kh(X), then there was no intersection on XY and the speculative advancement was conservative and can be accepted. Otherwise the ray can still be advanced from X by Δt=h(X). Keinert et al. call this over-relaxed sphere tracing (figure~\ref{fig:relaxation}. Naive sphere tracing advances the ray with only k=1, often discovering that the next point redundantly covers the interval just traversed.

© 2014 Keinert et al.
Top: sample points in white and ``unbounding spheres'' in purple from sphere
tracing. Bottom: Over-relaxed sphere tracing can speculatively take
larger steps (red) until it fails to find consecutive bounds
(yellow) and falls back to sphere tracing.

Over-relaxation is obviously most useful when the distance estimator in space is overly conservative for distance to the surface along the ray. There is a tradeoff between setting k close to 2 to gain the largest possible step and setting k close to 1 to reduce the number of times the speculative advancement fails. Because success doubles the step distance and failure doubles the number of evaluations of distance estimator h per iteration, over-relaxed sphere tracing can double or halve the performance compared to naive sphere tracing. Keinert et al. observe that k=1.2 gives a net 25% reduction in tracing time for the complex urban environment shown in the figure below, which appeared in the Mercury demoscene production The Timeless.

© 2014 Mercury
The Timeless demoscene production rendered with
sphere tracing optimizations to implicit surface ray marching

Bounding Spheres

When working with implicit surfaces, operations on distance estimators make it possible to build complex scenes by layering operations on simple primitives. Doing so offers great expressive power and programming elegance at a potentially high performance cost. This is because rays that pass nowhere near a surface must still evaluate the distance function for it.

The parse tree of a complicated set of operations on distance estimators inherently forms a scene graph tree. Performance can be increased by avoiding descending branches of that tree that do not affect the result. This kind of pruning is a common computer science operation and yields order-of-growth increases, unlike the kind of small constant factor that can be obtained by micro-optimizing within a single distance estimator.

The easiest way to prune the tree is to abort computation within a distance estimator when an early, inexpensive test determines that the ray is very far from the surface. A simple bounding sphere accomplishes this and correctly returns a still-conservative value. For example, let expensiveDE be a computationally-expensive distance estimator for an surface that is known to be entirely contained within the sphere with center C and radius r. A fast bounding estimator first tests how close the point X is to the bounding sphere. This must be a distance less than that to the true surface. It then only invokes the full, expensive estimator if X lies within the bounding sphere.

Copy
  1. 1float boundingDE(Point3 X, Point3 C, float r) {
  2. 2 float t = length(X - C) - r;
  3. 3 if (t > 0) { return t; } else { return expensiveDE(X); }
  4. 4}

Square root is one of the most expensive operations to perform on a GPU. We can slightly increase the performance of the slow case of boundingDE without affecting the fast case by delaying the square root until the inside of the slow branch:

Copy
  1. 1float boundingDE(Point3 X, Point3 C, float rSquared) {
  2. 2 Point3 v = X - C;
  3. 3 float tSquared = dot(v, v) - rSquared;
  4. 4 if (tSquared > 0) {
  5. 5 return sqrt(tSquared);
  6. 6 } else {
  7. 7 return expensiveDE(X);
  8. 8 }
  9. 9}

It is also a good idea to branch to the full, expensive distance estimator if X is even close to the sphere. That is because the silhouettes of objects are the most expensive to trace using a numerical root finder. A ray passing by in a direction tangent to the surface appears to be very close to the surface to the omni-directional distance estimator, so the ray marching iterator takes very small steps, even though the ray is not actually approaching the surface quickly.

Introducing a false silhouette around each object through the bounding sphere can exacerbate this problem. We can separate the bounding radius from the test value to avoid that:

Copy
  1. 1float boundingDE(Point3 X, Point3 C, float rSquared) {
  2. 2 Point3 v = X - C;
  3. 3 float tSquared = dot(v, v) - rSquared;
  4. 4 if (tSquared > rSquared * 0.2) {
  5. 5 return sqrt(tSquared);
  6. 6 } else {
  7. 7 return expensiveDE(X);
  8. 8 }
  9. 9}

Reintroducing Analytic Roots

Geometric planes are are large surfaces that can cover a large amount of the screen. A ray caster following any ray near the plane will be constrained to march in steps no larger than the elevation of the ray above the plane, which may be quite small compared to the true distance to the next intersection with the scene.

We can obtain a good speedup for scenes that containh ground planes by performing the (efficient) analytic intersection with the plane and then using the ray marcher only for other surfaces. Spheres are a border case. The distance estimator is extremely fast and yields good estimates along the ray on the interior and far from the sphere. Yet, for rays that pass near the silhouette, an analytic solution is far faster than a ray marched one.

The figures below shows on top a rendering of a scene composed of implicit surfaces. On the bottom is a visualization of the number of invocations of the scene distance estimator at each pixel, where brighter pixels are more expensive. This scene uses the analytic ground plane and bounding sphere optimizations.

© 2015 Morgan McGuire
A reference scene of many different shapes defined by implicit surfaces.
The distance estimator and ray marcher was used for primary rays,
(soft) shadow rays, and ambient occlusion.
© 2015 Morgan McGuire
Visualization of the number of scene distance estimator invocations
at each pixel; black = 0, white = 20.

Note that in the above figures, silhouettes and surfaces seen at glancing angles are far more expensive than the interiors of objects, which are almost as efficient to trace as the ground plane itself. The screw-like shape and the heightfield are expensive because they have very conservative distance estimators. The silhouettes of shadows are also expensive--those are places where the ray for the visibility query to the light passes close to a surface and thus slows down as it approaches.

Other Optimization Strategies

Soft shadows, ambient occlusion, and in some cases antialiased pixels and depth of field can all be approximated efficiently using distance estimators because they track how close a point is to all surfaces in the scene. Under analytic ray tracing, these instead must be estimated using tens or hundreds of rays per pixel.

Once objects are surrounded in bounding spheres, traditional spatial subdivision data structures can be applied to them. For example, it is simple to compute a bounding volume hierarchy on the bounding spheres.

However, using a data structure on a GPU in graphics mode is a bit tricky because GLSL executes function invocation by inlining. Thus there is no true recursion for traversing a tree in a natural way. This also makes it hard to implement reflection and refraction at the same surface under Whitted ray tracing, since that creates a tree of rays. (Path tracing, photon tracing, and one of reflection or refraction without the other can all be implemented using loops.)

There are two ways to build an explicit stack to work around the lack of recursion. One is to build the stack global memory using OpenGL 4 image buffer operations. This has awkward syntax and can be slow. Another is to build the stack in local memory. This can be accomplished for recursive rays on recent hardware using code like the listing below. A similar explicit stack can be used to traverse data structures.

Copy
  1. 1struct RayStackFrame {
  2. 2 Point3 origin;
  3. 3 Vector3 direction;
  4. 4 Color3 weight;
  5. 5};
  6. 6RayStackFrame stack[MAX_STACK];
  7. 7int stackTop = 0;
  8. 8...
  9. 9stack[0] = RayStackFrame(X, w, Color3(1, 1, 1));
  10. 10while (stackTop >= 0) {
  11. 11 Color3 weight = stack[stackTop].weight;
  12. 12 ...
  13. 13 if (reflection) {
  14. 14 // cast a recursive ray by pushing onto the stack
  15. 15 // and attenuating by the magnitude of the BSDF impulse
  16. 16 ...
  17. 17 ++stackTop;
  18. 18 }
  19. 19 L_o += weight * L_scattered;
  20. 20}

Beware that local memory is significantly slower than register memory (where other local variables are stored), although significantly faster than global memory. Local memory is frequently implemented as a portion of the L1 cache. Also beware that on older hardware without local memory support, relative indexing into an array can compile to a chain of conditionals because there are no relative memory operations on arrays.

Some register-only tree traversal strategies developed the introduction of local and global memory write operations are appropriate for older hardware and may find renewed value for performance even on newer targets [Horn2007Stack] [Popov2007Stackless] .

Analytic and numerical roots can be mixed within a scene, as we did for the ground plane. Our simple ray tracer produces depth buffer values compatible with OpenGL's triangle rasterization, so implicit surfaces may be mixed freely with all primary ray strategies.

11. Some Online Examples in GLSL

Educational

I wrote these three heavily-documented examples to demonstrate how to set up an analytic and a ray marching renderer. These are on the Shadertoy website, which uses WebGL, a limited version of the full OpenGL supported by G3D. So, the code is a little less efficient and clear than the best case, but has the advantage of running in most current web browsers.

© 2013 Morgan McGuire
Analytic Tracer
© 2013 Morgan McGuire
Mandelbulb Explained
© 2013 Morgan McGuire
Legos. (Lego is a trademark of The Lego Group)

Aspirational

These three examples are by Iñigo Quilez, a graphics professional who's worked at Pixar and Oculus Story Studio. He's long contributed to the demoscene and online graphics community. These are three of the most impressive demos on the Shadertoy website and good (if a bit hard for the novice to parse) examples of how to use the implicit surface techniques described in this document.

© 2014 Iñigo Quilez
Dolphin.
© 2013 Iñigo Quilez
Mike.
© 2013 Iñigo Quilez
Elevated.

12. Further Reading

Implicit surfaces were first rendered using numerical root finding by Blinn [1982] . They've since been advanced significantly through research by many others. Gomes et al. give a good survey in their book [2009] .

The academic graphics community has largely worked in parallel with the demoscene community, which has been ray tracing these in real time with similar techniques since at least the early 2000's, but which has only recently begun to document and share their methods widely. Quilez has been a leading voice in spreading information about demoscene techniques through his personal website, the Shadertoy website, and recently some public presentations [Quilez20084k] and online videos [Quilez2014Video] . Swoboda's GDC 2012 presentation [2012] overviews the material from this document and then describes some of the performance issues on modern GPUs.

I've simplified some of the details of sphere tracing and distance estimators in this explanation. See Hart's SIGGRAPH course notes [1993] or Liktor's survey paper [2008] for more details on the mathematical constraints and ways of choosing optimal step sizes based on derivatives. See Keinert et al.'s [2014] paper for the current state of the art.

One of the most interesting applications of numerical methods for ray intersection is rendering fractals, which by definition have difficult surfaces to intersect (since they have unbounded area!) [Hart1989Fractal] .

An alternative approach for rendering surfaces that do not admit analytic intersection solutions is to convert them to an approximation that does, for example, a triangle mesh. A popular method for doing so is Lorensen's and Cline's marching cubes algorithm [1987] . Conversely, it is often desirable to convert an existing triangle mesh into a signed distance function for integration with a ray marcher (e.g., to achieve warping and smooth blending). Akleman and Chen [1999] give one implementation of such an operation. Swoboda [2012] discusses both triangle-to-implicit conversion and reverse in the context of modern GPUs.

The particular form of implicit surface defined by distance from a point set is very popular for modeling fluids. Fedkiw worked extensively with these and the book that he coauthored is a good reference [Osher2003LevelSet] . There's an entire subfield of rendering called point-based graphics that directly ray traces such representations, sometimes using implicit surface methods.

References

[Akleman1999Distance]
Generalized Distance Functions
Ergun Akleman and Jianer Chen
in 1999 Shape Modeling International, p. 72-79, March1, 1999.
Official URL: http://doi.ieeecomputersociety.org/10.1109/SMA.1999.749326
10.1109/SMA.1999.749326
[Blinn1982Blobs]
A Generalization of Algebraic Surface Drawing
James F. Blinn
ACM Transactions on Graphics 1:3, p. 235-256, ACM, New York, NY, USA, July1982.
Official URL: http://doi.acm.org/10.1145/357306.357310
10.1145/357306.357310
[Gomes2009Implicit]
Implicit Curves and Surfaces: Mathematics, Data Structures and Algorithms
Abel Gomes, Irina Voiculescu, Joaquim Jorge, Brian Wyvill, and Callum Galbraith
Springer Publishing Company, Incorporated, 2009.
[Hart1989Fractal]
Ray Tracing Deterministic 3-D Fractals
J. C. Hart, D. J. Sandin, and L. H. Kauffman
in Proceedings of the 16th Annual Conference on Computer Graphics and Interactive Techniques, p. 289-296, ACM, New York, NY, USA, 1989.
Official URL: http://doi.acm.org/10.1145/74333.74363
Free URL: http://graphics.cs.illinois.edu/sites/default/files/rtqjs.pdf
10.1145/74333.74363
[Hart1993Course]
Ray Tracing Implicit Surfaces
John C. Hart
p. 1-16, SIGGRAPH'93 Course Notes: Design, Visualization and Animation of Implicit Surfaces, 1993.
Free URL: http://graphics.cs.illinois.edu/sites/default/files/rtis-tr.pdf
[Hart1996Sphere]
Sphere Tracing: A Geometric Method for the Antialiased Ray Tracing of Implicit Surfaces
John C. Hart
The Visual Computer 12:10, p. 527-545, Springer, 1996.
Free URL: http://bit.ly/1KJcnsO
[Hoffman1985Blend]
Automatic Surface Generation in Computer Aided Design
C. Hoffman and J. Hopcroft
The Visual Computer, p. 92-100, 1985.
Free URL: http://www.cs.purdue.edu/homes/cmh/distribution/papers/Geometry/geo1.pdf
[Horn2007Stack]
Interactive K-D Tree GPU Raytracing
Daniel Reiter Horn, Jeremy Sugerman, Mike Houston, and Pat Hanrahan
in Proceedings of the 2007 Symposium on Interactive 3D Graphics and Games, p. 167-174, ACM, New York, NY, USA, 2007.
Official URL: http://doi.acm.org/10.1145/1230100.1230129
10.1145/1230100.1230129
[Keinert2014Sphere]
Enhanced Sphere Tracing
Benjamin Keinert, Henry Schäafer, Johann Korndörfer, Urs Ganse, and Marc Stamminger
in Proceedings of Smart Tools & Apps for Graphics, Andrea Giachetti (ed.), p. 1-8, EuroGraphics, 2014.
Official URL: http://diglib.eg.org/EG/DL/LocalChapterEvents/ItalChap/STAG2014/001-008.pdf
Free URL: http://lgdv.cs.fau.de/get/2234
[Liktor2008Implicit]
Ray Tracing Implicit Surfaces on the GPU
Gábor Liktor
Computer Graphics and Geometry Journal 10:3, 2008.
Free URL: http://www.cescg.org/CESCG-2008/papers/TUBudapest-Liktor-Gabor.pdf
[Lorensen1987MarchingCubes]
Marching Cubes: A High Resolution 3D Surface Construction Algorithm
William E. Lorensen and Harvey E. Cline
in Proceedings of the 14th Annual Conference on Computer Graphics and Interactive Techniques, p. 163-169, ACM, New York, NY, USA, 1987.
Official URL: http://doi.acm.org/10.1145/37401.37422
Free URL: https://www.cs.virginia.edu/johntran/GLunch/marchingcubes.pdf
10.1145/37401.37422
[Osher2003LevelSet]
Level Set Methods and Dynamic Implicit Surfaces
Stanley Osher and Ronald P. Fedkiw
Springer, New York, N.Y., 2003.
Official URL: http://opac.inria.fr/record=b1099358
[Popov2007Stackless]
Stackless KD-Tree Traversal for High Performance GPU Ray Tracing
Stefan Popov, Johannes Gunther, Hans-Peter Seidel, and Philipp Slusallek
Computer Graphics Forum 26:3, p. 415-424, 2007.
Official URL: http://dblp.uni-trier.de/db/journals/cgf/cgf26.html#PopovGSS07
[Quilez20084k]
Rendering Worlds With Two Triangles With Raytracing on the GPU in 4096 Bytes
Iñigo Quilez
Talk at NVScene, August22, 2008.
Free URL: http://www.iquilezles.org/www/material/nvscene2008/rwwtt.pdf
[Quilez2008Distance]
Modeling With Distance Functions
Iñigo Quilez
2008.
Official URL: http://www.iquilezles.org/www/articles/distfunctions/distfunctions.htm
[Quilez2014Video]
Formulanimations Tutorial :: The Principles of Painting With Maths
Iñigo Quilez
YouTube Video, July14, 2014.
Free URL: https://www.youtube.com/watch?v=0ifChJ0nJfM
[Swoboda2012Procedural]
Advanced Procedural Rendering in DirectX 11
Matt Swoboda
Talk at the Game Developers Conference, 2012.
Free URL: http://directtovideo.wordpress.com/2012/03/15/get-my-slides-from-gdc2012/
[AMD2019RDNA]
Introducing RDNA Architecture
and AMD
p. 25, Santa Clara, CA, 2019.
Official URL: https://www.amd.com/system/files/documents/rdna-whitepaper.pdf
[ASTM08Sun]
Standard Tables for Reference Solar Spectral Irradiances: Direct Normal and Hemispherical on 37° Tilted Surface
ASTM G173 - 03(2008), ASTM International, 2008.
Official URL: http://www.astm.org/Standards/G173.htm
[Adelson1991Plenoptic]
The Plenoptic Function and the Elements of Early Vision
Edward H. Adelson and James R. Bergen
in Computational Models of Visual Processing, p. 3-20, MIT Press, 1991.
[Akleman1999Distance]
Generalized Distance Functions
Ergun Akleman and Jianer Chen
in 1999 Shape Modeling International, p. 72-79, March1, 1999.
Official URL: http://doi.ieeecomputersociety.org/10.1109/SMA.1999.749326
10.1109/SMA.1999.749326
[Appel68Shading]
Some Techniques for Shading Machine Renderings of Solids
Arthur Appel
in Proceedings of the April 30-May 2, 1968, spring joint computer conference, p. 37-45, ACM, New York, NY, USA, 1968.
Official URL: http://doi.acm.org/10.1145/1468075.1468082
10.1145/1468075.1468082
[Arvo1990Particle]
Particle Transport and Image Synthesis
James Arvo and David Kirk
in SIGGRAPH, p. 63-66, 1990.
Official URL: http://dl.acm.org/citation.cfm?id=97886
[Ashdown1993NearField]
Near-Field Photometry: A New Approach
Ian Ashdown
Journal of the Illuminating Engineering Society 22:1, p. 163-180, Winter1993.
Official URL: http://citeseer.ist.psu.edu/ashdown92nearfield.html
[Ashikhmin2000Microfacet]
A Microfacet-Based BRDF Generator
Michael Ashikhmin, Simon Premože, and Peter Shirley
in SIGGRAPH '00: Proceedings of the 27th annual conference on Computer graphics and interactive techniques, p. 65-74, ACM Press/Addison-Wesley Publishing Co., New York, NY, USA, 2000.
http://doi.acm.org/10.1145/344779.344814
[Ashikhmin2002Anisotropic]
An Anisotropic Phong BRDF Model
Michael Ashikhmin and Peter Shirley
Journal of Graphics Tools 5, p. 25-32, 2002.
Official URL: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.18.4558&rep=rep1&type=pdf
[Bender1995Dictionary]
A Dictionary of Food and Nutrition
Arnold E. Bender and David A. Bender
Oxford University Press, 1995.
[Bernoulli1697Exponential]
Principia Calculi Exponentialium Seu Percurrentium
Jacob Bernoulli
Acta Eruditorum Anno MDCXCVII:V, p. 125-133, Leipzig, Grosse & Gleditsch, March1697.
[Berry1923Diffuse]
Diffuse Reflection of Light From a Matte Surface
and Eugene M. Berry
Journal of the Optical Society of America 7:9, p. 627-633, OSA, 1923.
Official URL: http://www.opticsinfobase.org/josa/abstract.cfm?uri=josa-7-8-627
[Blinn1976Texture]
Texture and Reflection in Computer Generated Images
James F. Blinn and Martin Newell
Communications of the ACM 19:10, p. 542-547, ACM, New York, NY, USA, October1976.
Official URL: http://doi.acm.org/10.1145/360349.360353
Free URL: http://ddm.ace.ed.ac.uk/lectures/DDM/Intro_Digital_Media/Lecture3/slides/p542-blinn.pdf
10.1145/360349.360353
[Blinn1977Reflection]
Models of Light Reflection for Computer Synthesized Pictures
James F. Blinn
in SIGGRAPH '77: Proceedings of the 4th annual conference on Computer graphics and interactive techniques, p. 192-198, ACM, New York, NY, USA, 1977.
Official URL: http://dl.acm.org/citation.cfm?id=563893
Free URL: https://www.microsoft.com/en-us/research/wp-content/uploads/1977/01/p192-blinn.pdf
http://doi.acm.org/10.1145/563858.563893
[Blinn1978Bump]
Simulation of Wrinkled Surfaces
James F. Blinn
SIGGRAPH Comput. Graph. 12:3, p. 286-292, ACM, New York, NY, USA, August1978.
Official URL: http://doi.acm.org/10.1145/965139.507101
[Blinn1982Blobs]
A Generalization of Algebraic Surface Drawing
James F. Blinn
ACM Transactions on Graphics 1:3, p. 235-256, ACM, New York, NY, USA, July1982.
Official URL: http://doi.acm.org/10.1145/357306.357310
10.1145/357306.357310
[Blinn1982Clouds]
Light Reflection Functions for Simulation of Clouds and Dusty Surfaces
James F. Blinn
SIGGRAPH Comput. Graph. 16:3, p. 21-29, ACM, New York, NY, USA, 1982.
http://doi.acm.org/10.1145/965145.801255
[Blinn93Perspective]
A Trip Down the Graphics Pipeline: The Homogeneous Perspective Transform
Jim Blinn
IEEE Computer Graphics and Applications, p. 75-88, May1993.
Official URL: http://ieeexplore.ieee.org/xpl/freeabs_all.jsp?arnumber=210494
[Bowmaker80Visual]
Visual Pigments of Rods and Cones in a Human Retina
J. K. Bowmaker and H. J. Dartnall
The Journal of Physiology, p. 501-511, January1980.
Official URL: http://www.ncbi.nlm.nih.gov/pmc/articles/PMC1279132/
[Box1958]
A Note on the Generation of Random Normal Deviates
G. E. P. Box and Mervin E. Muller
in The Annals of Mathematical Statistics, p. 610-611, 1958 .
Free URL: https://projecteuclid.org/download/pdf_1/euclid.aoms/1177706645
[Britannica2008Faraday]
Michael Faraday
Encyclopædia Britannica Online, September14, 2008.
Official URL: http://www.britannica.com/EBchecked/topic/201705/Michael-Faraday/26081/Later-life#ref=ref393103
[Brooks1978Mythical]
The Mythical Man-Month: Essays on Software Engineering
Frederick P. Brooks, Jr.
Addison-Wesley Longman Publishing Co., Inc., Boston, MA, USA, 1978.
[Bunnell04Shadows]
Shadow Map Antialiasing
Michael Bunnell and Fabio Pellacini
in GPU Gems, Randima Fernando (ed.), ch. 11, Addison-Wesley Professional, April1, 2004.
Official URL: http://http.developer.nvidia.com/GPUGems/gpugems_ch11.html
[Burley2012BRDF]
Physically-Based Shading at Disney
Brent Burley
in SIGGRAPH Physically Based Shading Course, p. 26, August2012.
Free URL: http://disney-animation.s3.amazonaws.com/library/s2012_pbs_disney_brdf_notes_v2.pdf
[C++11]
ISO/IEC 14882:2011
ISO/IEC
Stefanus Du Toit (ed.), p. 1338 , Specification of the C++ language. , September 1 , 2011 .
Official URL: http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=50372
Free URL: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3337.pdf
[Cabral1987Bump]
Bidirectional Reflection Functions From Surface Bump Maps
Brian Cabral, Nelson Max, and Rebecca Springmeyer
in SIGGRAPH '87: Proceedings of the 14th annual conference on Computer graphics and interactive techniques, p. 273-281, ACM, New York, NY, USA, 1987.
http://doi.acm.org/10.1145/37401.37434
[Caldirola61Energy]
Physics of High Energy Densities
Manuela Caldirola
Academic Press, 1961.
[Cass2016Languages]
The 2016 Top Programming Languages
Stephen Cass
in IEEE Spectrum, July 26 , 2016 .
Free URL: http://spectrum.ieee.org/computing/software/the-2016-top-programming-languages
[Catmull74Thesis]
A Subdivision Algorithm for Computer Display of Curved Surfaces
Edwin Earl Catmull
The University of Utah, 1974.
Free URL: http://www.pixartouchbook.com/storage/catmull_thesis.pdf
[ChaconStraub2014Git]
Pro Git 2nd Edition
Scott Chacon and Ben Straub
p. 456, Apress, November12, 2014.
Free URL: https://git-scm.com/book/en/v2
[Chiu1993Nonuniform]
Spatially Nonuniform Scaling Functions for High Contrast Images
K. Chiu, M. Herf, P. Shirley, S. Swamy, C. Wang, and K. Zimmerman
in Proceedings of Graphics Interface '93, p. 245-253, Morgan Kaufmann, 1993.
Official URL: http://citeseer.ist.psu.edu/viewdoc/summary?doi=10.1.1.136.5090
[Claustres2007Wavelet]
Wavelet Encoding of BRDFs for Real-Time Rendering
Luc Claustres, Loïc Barthe, and Mathias Paulin
in GI '07: Proceedings of Graphics Interface 2007, p. 169-176, ACM, New York, NY, USA, 2007.
http://doi.acm.org/10.1145/1268517.1268546
[Clinger90FloatingPoint]
How to Read Floating Point Numbers Accurately
William D. Clinger
in Proceedings of the ACM SIGPLAN 1990 conference on Programming language design and implementation, p. 92-101, ACM, New York, NY, USA, 1990.
Official URL: http://doi.acm.org/10.1145/93542.93557
[CollinsSussman2008Subversion]
Version Control With Subversion: Next Generation Open Source Version Control
Ben Collins-Sussman, Brian W. Fitzpatrick, and Michael Pilato
p. 432, O'Reilly Media, June2008.
Free URL: http://svnbook.red-bean.com/
[Cook1982Reflectance]
A Reflectance Model for Computer Graphics
R. L. Cook and K. E. Torrance
ACM Trans. Graph. 1:1, p. 7-24, ACM, New York, NY, USA, 1982.
http://doi.acm.org/10.1145/357290.357293
[Cook1984Distributed]
Distributed Ray Tracing
Robert L. Cook, Thomas Porter, and Loren Carpenter
SIGGRAPH Computer Graphics 18:3, p. 137-145, ACM, New York, NY, USA, 1984.
http://doi.acm.org/10.1145/964965.808590
[Cotes1714Logometria]
Logometria
Roger Cotes
Philosophical Transactions of the Royal Society 29:338, p. 5-45, The Royal Society, Jan-March1714.
Official URL: http://rstl.royalsocietypublishing.org/content/29/338-350/5.full.pdf
[DX10Data]
Data Conversion Rules
Microsoft
in Direct3D 10 Graphics, February3, 2012.
Official URL: http://msdn.microsoft.com/en-us/library/windows/desktop/dd607323(v=vs.85).aspx
[Deering1998Vision]
The Limits of Human Vision
and Michael F. Deering
in Proceedings of the 2nd International Immersive Projection Technology Workshop, 1998.
Free URL: http://www.michaelfrankdeering.com/Projects/EyeModel/limits.pdf
[Deering2005Eye]
Expanded Version of a Photon Accurate Model of the Human Eye
and Michael F. Deering
Work in progress, 2005.
Free URL: http://www.michaelfrankdeering.com/Projects/EyeModel/eyeExpanded.pdf
[Descartes1637Discourse]
Discourse on the Method of Rightly Conducting the Reason, and Searching for Truth in the Sciences
René Descartes
Ian Maire, 1637.
[Dijkstra59]
A Note on Two Problems in Connexion With Graphs
Edsgar W. Dijkstra
Numerische Mathematik 1:1, p. 269-271, Springer, 1959.
Official URL: http://www.springerlink.com/content/uu8608u0u27k7256/?MUD=MP
Free URL: http://monet.skku.ac.kr/course_materials/undergraduate/al/lecture/2006/Dijkstra.pdf
[Dobashi2002]
Interactive Rendering of Atmospheric Scattering Effects Using Graphics Hardware
Y. Dobashi , T. Yamamoto , and T. Nishita
in Proceedings of the ACM SIGGRAPH/EUROGRAPHICS conference on Graphics Hardware, p. 99–107, 2002 .
[Durer1525Measurement]
Underweysung Der Messung Mit Dem Zirckel Und Richtscheyt
Albrecht Dürer
1525.
Free URL: http://digital.slub-dresden.de/fileadmin/data/27778509X/27778509X_tif/jpegs/27778509X.pdf
[Durstenfeld1964]
Algorithm 235: Random Permutation
and R. Durstenfeld
Communications of the ACM 7:7, p. 420, ACM, New York, NY, USA, 1964.
Official URL: https://dl.acm.org/citation.cfm?doid=364520.364540
10.1145/364520.364540
[Eberly11Slerp]
A Fast and Accurate Algorithm for Computing SLERP
David Eberly
Journal of Graphics Tools 15:3, p. 161-176, Taylor and Francis, October11, 2011.
Official URL: http://www.tandfonline.com/doi/abs/10.1080/2151237X.2011.610255
[Eberly2003Physics]
Game Physics
and David H. Eberly
Morgan Kaufmann, 2003.
[Ebert2002Procedural]
Texturing and Modeling, Third Edition: A Procedural Approach 3rd Edition
David S. Ebert, F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steve Worley
p. 712, Morgan Kaufmann, 2002.
[Edwards2006BRDF]
The Halfway Vector Disk for BRDF Modeling
Dave Edwards, Solomon Boulos, Jared Johnson, Peter Shirley, Michael Ashikhmin, Michael Stark, and Chris Wyman
ACM Transactions on Graphics 25:1, p. 1-18, ACM, New York, NY, USA, 2006.
http://doi.acm.org/10.1145/1122501.1122502
[Edwards2006BRDF]
The Halfway Vector Disk for BRDF Modeling
Dave Edwards, Solomon Boulos, Jared Johnson, Peter Shirley, Michael Ashikhmin, Michael Stark, and Chris Wyman
ACM Transactions on Graphics 25:1, p. 1-18, 2006.
Official URL: http://dl.acm.org/citation.cfm?id=1122502
Free URL: http://www.cs.utah.edu/~boulos/papers/brdftog.pdf
[Eisemann2007Ray]
Fast Ray/Axis-Aligned Bounding Box Overlap Tests Using Ray Slopes
Martin Eisemann, Thorsten Grosch, Stefan Müller, and Marcus Magnor
journal of graphics, gpu, and game tools 12:4, p. 35-46, 2007.
Official URL: http://jgt.akpeters.com/papers/EisemannEtAl07/
[Ericson2005Collision]
Real-Time Collision Detection
Christer Ericson
p. 632, CRC Press, 2004.
[EuclidElements]
The Elements
Euclid
2008 edition edited by Richard Fitzpatrick, .
Official URL: http://farside.ph.utexas.edu/euclid/Elements.pdf
[Euler1748Infinitorum]
Introductio in Analysin Infinitorum
Leonhard Euler
Societatis Scientiarum Naturalium Helvecticae, 1748.
Official URL: http://eulerarchive.maa.org/pages/E101.html
[Fante1981Dielectric]
Relationship Between Radiative-Transport Theory and Maxwell's Equations in Dielectric Media
Ronald L. Fante
Journal of the Optical Society of America 71:4, p. 460-468, OSA, 1981.
Official URL: http://www.opticsinfobase.org/abstract.cfm?URI=josa-71-4-460
[Faraday1846Ray]
Thoughts on Ray Vibrations
Michael Faraday
lecture, 1846.
[Fenney03Compression]
Texture Compression Using Low-Frequency Signal Modulation
Simon Fenney
in Proceedings of the ACM SIGGRAPH/EUROGRAPHICS conference on Graphics Hardware, p. 84-91, Eurographics Association, Aire-la-Ville, Switzerland, Switzerland, 2003.
Official URL: http://dl.acm.org/citation.cfm?id=844174.844187
Free URL: http://web.onetel.net.uk/~simonnihal/assorted3d/fenney03texcomp.pdf
[Feynman1998Quantum]
Quantum Electrodynamics
R. P. Feynman
Addison-Wesley, 1998.
[Fisher1948]
Statistical Tables for Biological, Agricultural and Medical Research (3rd Ed.)
Ronald A. Fisher and Frank Yates
Oliver & Boyd, 1948.
[Fishkin1982Color]
Applying Color Science to Computer Graphics
Kenneth Paul Fishkin
1982.
[Folland99RealAnalysis]
Real Analysis: Modern Techniques and Their Applications, 2nd Edition
Gerald B. Folland
p. 386, John Wiley and Sons, Inc., 1999.
[Fuchs1980BSP]
On Visible Surface Generation by a Priori Tree Structures
H. Fuchs, Z. M. Kedem, and B. F. Naylor
ACM Computer Graphics 14, p. 124-133, 1980.
Official URL: http://dl.acm.org/citation.cfm?id=807481
Free URL: https://www.researchgate.net/profile/Henry_Fuchs2/publication/30869999_On_Visible_Surface_Generation_by_a_Priori_Tree_Structures/links/542af1b50cf29bbc126a7b75.pdf
[GLSL420]
The OpenGL Shading Language 4.20
John Kessenich
The Khronos Group, August7, 2011.
Official URL: http://www.opengl.org/registry/doc/GLSLangSpec.4.20.6.clean.pdf
[GLSL430]
The OpenGL Shading Language 4.30
John Kessenich, Dave Baldwin, and Randi Rost
John Kessenich (ed.), The Khronos Group, August3, 2012.
Official URL: http://www.opengl.org/registry/doc/GLSLangSpec.4.30.6.pdf
[Gershun1936Lightfield]
The Light Field
A. Gershun
Journal of Mathematics and Physics 18, p. 51-151, translated by P. Moon and G. Timoshenko (originally published in Moscow, 1936), MIT, 1939.
[Glassner89RayTracing]
An Introduction to Ray Tracing
Andrew S. Glassner (ed.), Academic Press Ltd., London, UK, 1989.
[Goldberg91FloatingPoint]
What Every Computer Scientist Should Know About Floating-Point Arithmetic
David Goldberg
ACM Computing Surveys 23:1, p. 5-48, ACM, New York, NY, March.
Official URL: http://doi.acm.org/10.1145/103162.103163
[Gombrich1977Illusion]
Art and Illusion: A Study in the Psychology of Pictorial Representation, 5th Edition
E. H. Gombrich
Phaidon Press, 1977.
[Gomes2009Implicit]
Implicit Curves and Surfaces: Mathematics, Data Structures and Algorithms
Abel Gomes, Irina Voiculescu, Joaquim Jorge, Brian Wyvill, and Callum Galbraith
Springer Publishing Company, Incorporated, 2009.
[Goral1984Radiosity]
Modeling the Interaction of Light Between Diffuse Surfaces
Cindy M. Goral, Kenneth E. Torrance, Donald P. Greenberg, and Bennett Battaile
in Proceedings of the 11th annual conference on Computer graphics and interactive techniques, p. 213-222, ACM, New York, NY, USA, 1984.
Official URL: http://doi.acm.org/10.1145/800031.808601
Free URL: http://www0.cs.ucl.ac.uk/research/vr/Projects/VLF/vlfpapers/radiosity/Goral__Modeling_the_Interaction_of_Light_Between_Diffuse_Surfaces.pdf
[Gortler1996Lumigraph]
The Lumigraph
Steven J. Gortler, Radek Grzeszczuk, Richard Szeliski, and Michael F. Cohen
in Proceedings of the 23rd annual conference on Computer graphics and interactive techniques, p. 43-54, ACM Press, 1996.
http://doi.acm.org/10.1145/237170.237200
[Graustein1930HomogeneousCh3]
Homogeneous Cartesian Coordinates. Linear Dependence of Points and Lines.
W. C. Graustein
in Introduction to Higher Geometry, ch. 3, p. 29-49, New York: Macmillan, 1930.
[Guy2004Gems]
Graphics Gems Revisited
Stéphane Guy and Cyril Soler
ACM Transactions on Graphics (Proceedings of the SIGGRAPH conference), 2004.
Official URL: http://artis.imag.fr/Publications/2004/GS04
[Guy2004Gems]
Graphics Gems Revisited: Fast and Physically-Based Rendering of Gemstones
Stéephane Guy and Cyril Soler
ACM Trans. Graph. 23:3, p. 231-238, ACM, New York, NY, USA, 2004.
http://doi.acm.org/10.1145/1015706.1015708
[Haase1992Pigmented]
Modeling Pigmented Materials for Realistic Image Synthesis
Chet S. Haase and Gary W. Meyer
ACM Trans. Graph. 11:4, p. 305-335, ACM, New York, NY, USA, 1992.
http://doi.acm.org/10.1145/146443.146452
[Hanrahan1993Layered]
Reflection From Layered Surfaces Due to Subsurface Scattering
Pat Hanrahan and Wolfgang Krueger
in SIGGRAPH '93: Proceedings of the 20th annual conference on Computer graphics and interactive techniques, p. 165-174, ACM, New York, NY, USA, 1993.
http://doi.acm.org/10.1145/166117.166139
[Hapke1963Lunar]
A Theoretical Photometric Function for the Lunar Surface
B. W. Hapke
Journal of Geophysics Research 68, p. 4571-4586, 1963.
[Hardy1999Ramanujan]
Ramanujan: Twelve Lectures on Subjects Suggested by His Life and Work
G. H. Hardy
p. 254, Chelsea Publishing Co, 1999.
[Hart1989Fractal]
Ray Tracing Deterministic 3-D Fractals
J. C. Hart, D. J. Sandin, and L. H. Kauffman
in Proceedings of the 16th Annual Conference on Computer Graphics and Interactive Techniques, p. 289-296, ACM, New York, NY, USA, 1989.
Official URL: http://doi.acm.org/10.1145/74333.74363
Free URL: http://graphics.cs.illinois.edu/sites/default/files/rtqjs.pdf
10.1145/74333.74363
[Hart1993Course]
Ray Tracing Implicit Surfaces
John C. Hart
p. 1-16, SIGGRAPH'93 Course Notes: Design, Visualization and Animation of Implicit Surfaces, 1993.
Free URL: http://graphics.cs.illinois.edu/sites/default/files/rtis-tr.pdf
[Hart1996Sphere]
Sphere Tracing: A Geometric Method for the Antialiased Ray Tracing of Implicit Surfaces
John C. Hart
The Visual Computer 12:10, p. 527-545, Springer, 1996.
Free URL: http://bit.ly/1KJcnsO
[He1991BSDF]
A Comprehensive Physical Model for Light Reflection
Xiao D. He, Kenneth E. Torrance, François X. Sillion, and Donald P. Greenberg
SIGGRAPH Comput. Graph. 25:4, p. 175-186, ACM, New York, NY, USA, 1991.
http://doi.acm.org/10.1145/127719.122738
[He1992Reflection]
A Fast and Accurate Light Reflection Model
Xiao D. He, Patrick O. Heynen, Richard L. Phillips, Kenneth E. Torrance, David H. Salesin, and Donald P. Greenberg
in SIGGRAPH '92: Proceedings of the 19th annual conference on Computer graphics and interactive techniques, p. 253-254, ACM, New York, NY, USA, 1992.
http://doi.acm.org/10.1145/133994.134073
[Heart68AStar]
A Formal Basis for the Heuristic Determination of Minimum Cost Paths
Peter E. Heart, Nils J. Nilsson, and Bertram Raphael
IEEE Transactions on Systems Science and Cybernetics, p. 100-107, IEEE, 1968.
Official URL: http://ieeexplore.ieee.org/xpl/articleDetails.jsp?arnumber=4082128
Free URL: http://130.107.64.109/pubs/files/834.pdf
[Heckbert1989Refraction]
Derivation of Refraction Formulas
Paul Heckbert
in An introduction to ray tracing, Andrew S. Glassner (ed.), Academic Press Ltd., London, UK, 1989.
[Heckbert1990Radiosity]
Adaptive Radiosity Textures for Bidirectional Ray Tracing
Paul S. Heckbert
in SIGGRAPH '90: Proceedings of the 17th annual conference on Computer graphics and interactive techniques, p. 145-154, ACM, New York, NY, USA, 1990.
http://doi.acm.org/10.1145/97879.97895
[Heitz2014Masking]
Understanding the Masking-Shadowing Function in Microfacet-Based BRDFs
Eric Heitz
JCGT 3:2, p. 48-107, 2014.
Free URL: http://jcgt.org/published/0003/02/03/paper.pdf
[Henyey1941Diffuse]
Diffuse Radiation in the Galaxy
L. G. Henyey and J. L. Greenstein
Astrophysical Journal 93, p. 531-536, 1941.
Free URL: http://adsabs.harvard.edu/abs/1941ApJ....93...70H
[Hershenson]
The Moon Illusion
Maurice Hershenson (ed.), Lawrence Erlbaum Associates, Hillsdale, NJ, 1989.
Official URL: http://books.google.co.uk/books?id=x1qcL4CTwlIC
[Hoffman1985Blend]
Automatic Surface Generation in Computer Aided Design
C. Hoffman and J. Hopcroft
The Visual Computer, p. 92-100, 1985.
Free URL: http://www.cs.purdue.edu/homes/cmh/distribution/papers/Geometry/geo1.pdf
[Hoffman2013Course]
Background: Physics and Math of Shading
Naty Hoffman
in SIGGRAPH Physically Based Shading Course, p. 41, August2013.
Free URL: http://blog.selfshadow.com/publications/s2013-shading-course/hoffman/s2013_pbs_physics_math_notes.pdf
[Horn2007Stack]
Interactive K-D Tree GPU Raytracing
Daniel Reiter Horn, Jeremy Sugerman, Mike Houston, and Pat Hanrahan
in Proceedings of the 2007 Symposium on Interactive 3D Graphics and Games, p. 167-174, ACM, New York, NY, USA, 2007.
Official URL: http://doi.acm.org/10.1145/1230100.1230129
10.1145/1230100.1230129
[IEEE-754-2008]
754-2008 IEEE Standard for Floating-Point Arithmetic
p. 58, August29, 2008.
Official URL: http://ieeexplore.ieee.org/servlet/opac?punumber=4610933
[Immel1986Radiosity]
A Radiosity Method for Non-Diffuse Environments
David S. Immel, Michael F. Cohen, and Donald P. Greenberg
SIGGRAPH Computer Graphics 20, p. 133-142, ACM, New York, NY, USA, August1986.
Official URL: http://doi.acm.org/10.1145/15886.15901
Free URL: https://www.researchgate.net/profile/Michael_Cohen12/publication/220720201_A_Radiosity_Method_for_Non-Diffuse_Environments/links/00b49520a6f1482f85000000/A-Radiosity-Method-for-Non-Diffuse-Environments.pdf?origin=publication_detail
[Intel2019Manual]
Intel® 64 and IA-32 Architectures Software Developer’s Manual
and Intel
p. 4922, Santa Clara, CA, May2019.
Official URL: https://software.intel.com/sites/default/files/managed/39/c5/325462-sdm-vol-1-2abcd-3abcd.pdf
[Jensen1996Photon]
Global Illumination Using Photon Maps
Henrik Wann Jensen
in Proceedings of the eurographics workshop on Rendering techniques '96, p. 21-30, Springer-Verlag, London, UK, 1996.
Official URL: http://graphics.ucsd.edu/~henrik/papers/photon_map/
[Jensen2001Subsurface]
A Practical Model for Subsurface Light Transport
Henrik Wann Jensen, Stephen R. Marschner, Marc Levoy, and Pat Hanrahan
in SIGGRAPH '01: Proceedings of the 28th annual conference on Computer graphics and interactive techniques, p. 511-518, ACM, New York, NY, USA, 2001.
http://doi.acm.org/10.1145/383259.383319
[Kajiya1986Rendering]
The Rendering Equation
James T. Kajiya
SIGGRAPH Computer Graphics 20:4, p. 143-150, ACM, New York, NY, USA, 1986.
Official URL: http://doi.acm.org/10.1145/15886.15902
[Kajiya85Anisotropic]
Anisotropic Reflection Models
James T. Kajiya
in SIGGRAPH '85: Proceedings of the 12th annual conference on Computer graphics and interactive techniques, p. 15-21, ACM, New York, NY, USA, 1985.
http://doi.acm.org/10.1145/325334.325167
[Kanwal1998Functions]
Generalized Functions: Theory and Technique 2nd Edition
Ram P. Kanwal
p. 474, Birkhäser Boston, 1998.
[Karis2013Unreal]
Real Shading in Ureal Engine 4
Brian Karis
in SIGGRAPH Physically Based Shading in Theory and Practice Course, p. 21, August2013.
Free URL: http://blog.selfshadow.com/publications/s2013-shading-course/karis/s2013_pbs_epic_notes_v2.pdf
[Kass90Fluid]
Rapid, Stable Fluid Dynamics for Computer Graphics
Michael Kass and Gavin Miller
SIGGRAPH Computer Graphics 24:4, p. 49-57, ACM, New York, NY, 1990.
Official URL: http://dl.acm.org/citation.cfm?id=97884
[Kautz2002SH]
Fast, Arbitrary BRDF Shading for Low-Frequency Lighting Using Spherical Harmonics
Jan Kautz, Peter-Pike Sloan, and John Snyder
in EGRW '02: Proceedings of the 13th Eurographics workshop on Rendering, p. 291-296, Eurographics Association, Aire-la-Ville, Switzerland, Switzerland, 2002.
Official URL: http://dl.acm.org/citation.cfm?id=581934
[Keinert2014Sphere]
Enhanced Sphere Tracing
Benjamin Keinert, Henry Schäafer, Johann Korndörfer, Urs Ganse, and Marc Stamminger
in Proceedings of Smart Tools & Apps for Graphics, Andrea Giachetti (ed.), p. 1-8, EuroGraphics, 2014.
Official URL: http://diglib.eg.org/EG/DL/LocalChapterEvents/ItalChap/STAG2014/001-008.pdf
Free URL: http://lgdv.cs.fau.de/get/2234
[Kernighan88C]
The C Programming Language, 2nd Edition
Brian W. Kernighan and Dennis M. Ritchie
Prentice Hall, 1988.
[Kimura1986Absorptance]
Absorptance Measurements of Metal Mirrors at Glancing Incidence
Wayne D. Kimura and Dennis H. Ford
Appl. Opt. 25:20, p. 3740-3750, OSA, 1986.
Official URL: http://ao.osa.org/abstract.cfm?URI=ao-25-20-3740
[Kubelka1931Paint]
Ein Beitrag Zur Optik Der Farbanstriche
Kubelka, P. and Munk, F.
Zurich Techn. Physik 12, p. 593, 1931.
[Lafortune1993Bidirectional]
Bidirectional Path Tracing
Eric P. Lafortune and Yves D. Willems
in Proceedings of CompuGraphics, p. 145-153, December1993.
Free URL: http://www.cs.princeton.edu/courses/archive/fall03/cs526/papers/lafortune93.pdf
[Lafortune1994Phong]
Using the Modified Phong Brdf for Physically Based Rendering
Eric P. Lafortune and Yves D. Willems
p. 19, Leuven, Belgium, Nov1994.
Official URL: http://www.graphics.cornell.edu/ eric/Phong.html
[Lafortune1994Physically]
A Theoretical Framework for Physically Based Rendering
Eric P. Lafortune and Yves D. Willems
p. 97-108, 1994.
Free URL: http://www.cs.rpi.edu/~cutler/classes/advancedgraphics/S11/papers/lafortune_94.pdf
[Lafortune1997Reflectance]
Non-Linear Approximation of Reflectance Functions
Eric P. F. Lafortune, Sing-Choong Foo, Kenneth E. Torrance, and Donald P. Greenberg
in SIGGRAPH '97: Proceedings of the 24th annual conference on Computer graphics and interactive techniques, p. 117-126, ACM Press/Addison-Wesley Publishing Co., New York, NY, USA, 1997.
http://doi.acm.org/10.1145/258734.258801
[Lalonde1997Wavelet]
A Wavelet Representation of Reflectance Functions
Paul Lalonde and Alain Fournier
IEEE Transactions on Visualization and Computer Graphics 3:4, p. 329-336, IEEE Educational Activities Department, Piscataway, NJ, USA, 1997.
http://dx.doi.org/10.1109/2945.646236
[Lambert1760Photometrie]
Photometrie
Johann Heinrich Lambert
p. 433, W. Engelmann, 1760.
Free URL: http://archive.org/details/lambertsphotome00lambgoog
[Lange1999pi]
An Elegant Continued Fraction for π
L. J. Lange
The American Mathematical Monthly 106:5, p. 456-458, May1999.
Official URL: http://www.jstor.org/stable/2589152
[Lawrence2004BRDF]
Efficient BRDF Importance Sampling Using a Factored Representation
Jason Lawrence, Szymon Rusinkiewicz, and Ravi Ramamoorthi
in SIGGRAPH '04: ACM SIGGRAPH 2004 Papers, p. 496-505, ACM, New York, NY, USA, 2004.
http://doi.acm.org/10.1145/1186562.1015751
[Lawrence2006Editing]
Inverse Shade Trees for Non-Parametric Material Representation and Editing
Jason Lawrence, Aner Ben-Artzi, Christopher DeCoro, Wojciech Matusik, Hanspeter Pfister, Ravi Ramamoorthi, and Szymon Rusinkiewicz
ACM Trans. Graph. 25:3, p. 735-745, ACM, New York, NY, USA, 2006.
http://doi.acm.org/10.1145/1141911.1141949
[Lepage1978]
A New Algorithm for Adaptive Multidimensional Integration
and G. Peter Lepage
in Journal of Computational Physics, p. 192–203, Elsevier, 1978 .
Official URL: http://www.sciencedirect.com/science/article/pii/0021999178900049
Free URL: http://inspirehep.net/record/119196/files/slac-pub-1839.pdf
[Levoy1996Lightfield]
Light Field Rendering
Marc Levoy and Pat Hanrahan
in Proceedings of the 23rd annual conference on Computer graphics and interactive techniques, p. 31-42, ACM Press, 1996.
http://doi.acm.org/10.1145/237170.237199
[Liktor2008Implicit]
Ray Tracing Implicit Surfaces on the GPU
Gábor Liktor
Computer Graphics and Geometry Journal 10:3, 2008.
Free URL: http://www.cescg.org/CESCG-2008/papers/TUBudapest-Liktor-Gabor.pdf
[Lorensen1987MarchingCubes]
Marching Cubes: A High Resolution 3D Surface Construction Algorithm
William E. Lorensen and Harvey E. Cline
in Proceedings of the 14th Annual Conference on Computer Graphics and Interactive Techniques, p. 163-169, ACM, New York, NY, USA, 1987.
Official URL: http://doi.acm.org/10.1145/37401.37422
Free URL: https://www.cs.virginia.edu/johntran/GLunch/marchingcubes.pdf
10.1145/37401.37422
[MIL-STD-1472F]
Department of Defense Design Criteria Standard, Human Engineering
United States of America Department of Defense
August23, 1999.
Official URL: http://www.public.navy.mil/navsafecen/Documents/acquisition/MILSTD1472F.pdf
[Marschner2003Hair]
Light Scattering From Human Hair Fibers
Stephen R. Marschner, Henrik Wann Jensen, Mike Cammarano, Steve Worley, and Pat Hanrahan
ACM Trans. Graph. 22:3, p. 780-791, ACM, New York, NY, USA, 2003.
http://doi.acm.org/10.1145/882262.882345
[Matusik2003Data]
A Data-Driven Reflectance Model
Wojciech Matusik, Hanspeter Pfister, Matt Brand, and Leonard McMillan
ACM Trans. Graph. 22:3, p. 759-769, ACM, New York, NY, USA, 2003.
http://doi.acm.org/10.1145/882262.882343
[Metropolis1953]
Equations of State Calculations by Fast Computing Machines
Nicholas Metropolis , Arianna W. Rosenbluth , Marshall N. Rosenbluth , Augusta H. Teller , and Edward Teller
in Journal of Chemical Physics, p. 1087–1092, 1953 .
Official URL: http://aip.scitation.org/doi/pdf/10.1063/1.1699114
[Meyers05Effective]
Effective C++, Third Edition
Scott Meyers
Addison Wesley, 2005.
Official URL: http://www.informit.com/store/product.aspx?isbn=0321334876
[Meyers14Effective]
Effective Modern C++
Scott Meyers
O'Reilly Media, 2014.
Official URL: http://shop.oreilly.com/product/0636920033707.do
[Minnaert1941Reciprocity]
The Reciprocity Principle in Lunar Photometry
Minnaert
Astrophysical Journal 93, p. 403-410, May1941.
10.1086/144279
[NASA12Sun]
Sun: Facts & Figures
NASA
NASA Website, January27, 2012.
Official URL: http://solarsystem.nasa.gov/planets/profile.cfm?Display=Facts&Object=Sun
[NVIDIA2018Turing]
NVIDIA Turing GPU Architecture
and NVIDIA
p. 86, Santa Clara, CA, 2018.
Official URL: https://www.nvidia.com/content/dam/en-zz/Solutions/design-visualization/technologies/turing-architecture/NVIDIA-Turing-Architecture-Whitepaper.pdf
[Newell75Thesis]
The Utilization of Procedure Models in Digital Image Synthesis
Martin Newell
David C. Evans, Advisor, The University of Utah, 1975.
Free URL: http://content.lib.utah.edu/cdm/ref/collection/uspace/id/4999
[Newton1704Opticks]
Opticks
Isaac Newton
Sam Smith and Benj. Walford, 1704.
Free URL: https://archive.org/details/Optics_285
[Ngan2004BRDF]
Experimental Validation of Analytical BRDF Models
Addy Ngan, Fréo Durand, and Wojciech Matusik
in SIGGRAPH '04: ACM SIGGRAPH 2004 Sketches, p. 90, ACM, New York, NY, USA, 2004.
http://doi.acm.org/10.1145/1186223.1186336
[Ngan2005BRDF]
Experimental Analysis of BRDF Models
Addy Ngan, Frédo Durand, and Wojciech Matusik
in Proceedings of the Eurographics Symposium on Rendering, p. 117-226, Eurographics Association, 2005.
Official URL: http://people.csail.mit.edu/addy/research/brdf/
[Nicodemus1977Reflectance]
Geometrical Considerations and Nomenclature for Reflectance
F. E. Nicodemus, J. C. Richmond, J. J. Hsia, I. W. Ginsberg, and T. Limperis
in Final Report National Bureau of Standards, Washington, DC. Inst. for Basic Standards., Ott (ed.), October1977.
Official URL: http://www.amazon.com/Geometrical-considerations-nomenclature-reflectance-Standards/dp/B003TSD18S
[Nishita1985Interreflection]
Continuous Tone Representation of Three-Dimensional Objects Taking Account of Shadows and Interreflection
Tomoyuki Nishita and Eihachiro Nakamae
in SIGGRAPH '85: Proceedings of the 12th annual conference on Computer graphics and interactive techniques, p. 23-30, ACM, New York, NY, USA, 1985.
http://doi.acm.org/10.1145/325334.325169
[Nishita1993Atmospheric]
Display of the Earth Taking Into Account Atmospheric Scattering
Tomoyuki Nishita, Takao Sirai, Katsumi Tadamura, and Eihachiro Nakamae
in SIGGRAPH '93: Proceedings of the 20th annual conference on Computer graphics and interactive techniques, p. 175-182, ACM, New York, NY, USA, 1993.
http://doi.acm.org/10.1145/166117.166140
[Oosterom83Solidangle]
The Solid Angle of a Plane Triangle
Van Oosterom, A. and Strackee, J.
IEEE Transactions on Biomedical Engineering 30:2, p. 125 - 126, Feb.1983.
[Optics]
Optics
Eugene Hecht
p. 698, 4th Edition, Addison-Wesley, 2002.
[Oren1993Diffuse]
Diffuse Reflectance From Rough Surfaces
M. Oren and S.K. Nayar
in IEEE Conference on Computer Vision and Pattern Recognition (CVPR), p. 763-764, June1993.
Official URL: http://ieeexplore.ieee.org/xpl/freeabs_all.jsp?arnumber=341163
[Oren1994Reflectance]
Generalization of Lambert's Reflectance Model
M. Oren and S.K. Nayar
in ACM 21st Annual Conference on Computer Graphics and Interactive Techniques (SIGGRAPH), p. 239-246, Jul1994.
[Osher2003LevelSet]
Level Set Methods and Dynamic Implicit Surfaces
Stanley Osher and Ronald P. Fedkiw
Springer, New York, N.Y., 2003.
Official URL: http://opac.inria.fr/record=b1099358
[PBRT]
Physically Based Rendering: From Theory to Implementation
Matt Pharr and Greg Humphreys
Morgan Kaufmann Publishers Inc., San Francisco, CA, USA, 2004.
[PBRT2]
Physically Based Rendering: From Theory to Implementation, Second Edition
Matt Pharr and Greg Humphreys
Morgan Kaufmann Publishers Inc., San Francisco, CA, USA, 2010.
[PDIS]
Principles of Digital Image Synthesis
Andrew S. Glassner
Morgan Kaufmann Publishers Inc., San Francisco, CA, USA, 1994.
Free URL: http://realtimerendering.com/Principles_of_Digital_Image_Synthesis_v1.0.1.pdf
[PP3]
Computer Graphics: Principles and Practice 3rd Edition
John F. Hughes, Andries van Dam, Morgan McGuire, David F. Sklar, James D. Foley, Steven K. Feiner, and Kurt Akeley
Addison-Wesley, 2013.
[Parker1999Ray]
Interactive Ray Tracing
Steven Parker, William Martin, Peter-Pike J. Sloan, Seter Shirley, Brian Smits, and Charles Hansen
in Proceedings of the 1999 symposium on Interactive 3D graphics (I3D'99), p. 119-126, ACM, 1999.
Official URL: http://dl.acm.org/citation.cfm?id=300537
Free URL: http://www.ppsloan.org/publications/rtrt99.pdf
[Parker2010OptiX]
OptiX: A General Purpose Ray Tracing Engine
Steven G. Parker, James Bigler, Andreas Dietrich, Heiko Friedrich, Jared Hoberock, David Luebke, David McAllister, Morgan McGuire, Keith Morley, Austin Robison, and Martin Stich
ACM Transactions on Graphics 29:4, p. 66:1-66:13, ACM, New York, NY, USA, July2012.
Official URL: http://doi.acm.org/10.1145/1778765.1778803
[Peers2006Subsurface]
A Compact Factored Representation of Heterogeneous Subsurface Scattering
Pieter Peers, Karl vom Berge, Wojciech Matusik, Ravi Ramamoorthi, Jason Lawrence, Szymon Rusinkiewicz, and Philip Dutré
in SIGGRAPH '06: ACM SIGGRAPH 2006 Papers, p. 746-753, ACM, New York, NY, USA, 2006.
http://doi.acm.org/10.1145/1179352.1141950
[Pfister2000Surfels]
Surfels: Surface Elements as Rendering Primitives
Hanspeter Pfister, Matthias Zwicker, Jeroen van Baar, and Markus Gross
in Proceedings of the 27th annual conference on Computer graphics and interactive techniques, p. 335-342, ACM Press/Addison-Wesley Publishing Co., New York, NY, USA, 2000.
Official URL: http://dx.doi.org/10.1145/344779.344936
[Phong1973Thesis]
Illumination for Computer-Generated Images
Bui Tuong Phong
The University of Utah, 1973.
Free URL: http://www.dtic.mil/cgi-bin/GetTRDoc?Location=U2&doc=GetTRDoc.pdf&AD=ADA008786
[Phong1975Illumination]
Illumination for Computer Generated Pictures
Bui Tuong Phong
Commun. ACM, p. 311-317, ACM, June1975.
Official URL: http://dl.acm.org/citation.cfm?id=360839
Free URL: http://www.cs.northwestern.edu/~ago820/cs395/Papers/Phong_1975.pdf
[Popov2007Stackless]
Stackless KD-Tree Traversal for High Performance GPU Ray Tracing
Stefan Popov, Johannes Gunther, Hans-Peter Seidel, and Philipp Slusallek
Computer Graphics Forum 26:3, p. 415-424, 2007.
Official URL: http://dblp.uni-trier.de/db/journals/cgf/cgf26.html#PopovGSS07
[Porter1984Compositing]
Compositing Digital Images
Thomas Porter and Tom Duff
SIGGRAPH Comput. Graph. 18:3, p. 253-259, ACM, New York, NY, USA, January1984.
Official URL: http://doi.acm.org/10.1145/964965.808606
[Poulin1990Anisotropic]
A Model for Anisotropic Reflection
Pierre Poulin and Alain Fournier
in SIGGRAPH '90: Proceedings of the 17th annual conference on Computer graphics and interactive techniques, p. 273-282, ACM, New York, NY, USA, 1990.
http://doi.acm.org/10.1145/97879.97909
[Preisendorfer1965Radiative]
Radiative Transfer in Discrete Spaces
R. W. Preisendorfer
Pergamon Press, 1965.
[Press1990]
Recursive Stratified Sampling for Multidimensional Monte Carlo Integration
William H. Press and Glennys R. Farrar
in Computers in Physics, p. 190–195, 1990 .
[Purcell2004Thesis]
Ray Tracing on a Stream Processor
Timothy J. Purcell
Stanford University, Stanford, CA, USA, 2004.
Free URL: https://graphics.stanford.edu/papers/tpurcell_thesis/tpurcell_thesis.pdf
[Quilez20084k]
Rendering Worlds With Two Triangles With Raytracing on the GPU in 4096 Bytes
Iñigo Quilez
Talk at NVScene, August22, 2008.
Free URL: http://www.iquilezles.org/www/material/nvscene2008/rwwtt.pdf
[Quilez2008Distance]
Modeling With Distance Functions
Iñigo Quilez
2008.
Official URL: http://www.iquilezles.org/www/articles/distfunctions/distfunctions.htm
[Quilez2014Video]
Formulanimations Tutorial :: The Principles of Painting With Maths
Iñigo Quilez
YouTube Video, July14, 2014.
Free URL: https://www.youtube.com/watch?v=0ifChJ0nJfM
[RISUPM]
Realistic Image Synthesis Using Photon Mapping
Henrik Wann Jensen
(2nd printing), A. K. Peters, Ltd., Natick, MA, USA, 2001.
Official URL: http://graphics.ucsd.edu/~henrik/papers/book/
[RTR3]
Real-Time Rendering 3rd Edition
Tomas Akenine-Möller, Eric Haines, and Naty Hoffman
p. 1045, A. K. Peters, Ltd., Natick, MA, USA, 2008.
[Reeves87Shadows]
Rendering Antialiased Shadows With Depth Maps
William T. Reeves, David H. Salesin, and Robert. L. Cook
SIGGRAPH Computer Graphics 21:4, p. 283-291, ACM, New York, NY, USA, August1987.
Official URL: http://dl.acm.org/citation.cfm?id=37435
[Rubin1980BVH]
A 3-Dimensional Representation for Fast Rendering of Complex Scenes
Steven M. Rubin and Turner Whitted
ACM Computer Graphics (SIGGRAPH'80 Proceedings) 14, p. 110-116, 1980.
Official URL: http://dl.acm.org/citation.cfm?id=807479
Free URL: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.133.6937&rep=rep1&type=pdf
[Sahl984Lenses]
On Burning Mirrors and Lenses
Abu Sa`d al-`Ala' ibn Sahl
984.
[SchaepmanStrub2006Reflectance]
Reflectance Quantities in Optical Remote Sensing-Definitions and Case Studies
Gabriela Schaepman-Strub, M. E. Schaepman, Thomas Painter, S. Dangel, and J. V. Martonchik
Remote Sensing of Environment 103, p. 27-42, Elsevier, July2006.
Free URL: http://www2.geog.ucl.ac.uk/~mdisney/teaching/PPRS/papers/schaepman_et_al.pdf
[Schlick1992Thesis]
Divers ÉLéMents Pour Une SynthèSe D'images RéAlistes
Christophe Schlick
Université Bordeaux 1, Nov1992.
[Schlick1993Reflectance]
A Customizable Reflectance Model for Everyday Rendering
Christophe Schlick
in In Fourth Eurographics Workshop on Rendering, p. 73-83, 1993.
Official URL: http://citeseer.ist.psu.edu/viewdoc/summary?doi=10.1.1.49.2115
[Schlick1994BRDF]
An Inexpensive BRDF Model for Physically-Based Rendering
Christophe Schlick
Computer Graphics Forum 13, p. 233-246, 1994.
Official URL: http://dept-info.labri.fr/~schlick/DOC/eur2.html
[Schroder1995Wavelet]
Spherical Wavelets: Efficiently Representing Functions on the Sphere
Peter Schröder and Wim Sweldens
in SIGGRAPH '95: Proceedings of the 22nd annual conference on Computer graphics and interactive techniques, p. 161-172, ACM, New York, NY, USA, 1995.
http://doi.acm.org/10.1145/218380.218439
[Shirley1997Reflection]
A Practitioners' Assessment of Light Reflection Models
Shirley, P., Smits, B., Hu, H., and Lafortune, E.
in PG '97: Proceedings of the 5th Pacific Conference on Computer Graphics and Applications, p. 40, IEEE Computer Society, Washington, DC, USA, 1997.
Official URL: http://www.cs.utah.edu/~shirley/papers/reflect/
[Shoemake1985Quaternion]
Animating Rotation With Quaternion Curves
and Ken Shoemake
in Proceedings of the 12th annual conference on Computer graphics and interactive techniques (SIGGRAPH 1985), p. 245-254, ACM, 1985.
Official URL: http://dl.acm.org/citation.cfm?id=325242
[Siegel1992MoonBRDF]
Thermal Radiation Heat Transfer, 3rd Edition
Robert Siegel and John R. Howell
Hemisphere Publishing, 1992.
[Smith1967Shadowing]
Geometrical Shadowing of a Random Rough Surface
and B. Smith
IEEE Transactions on Antennas and Propagation 15:5, p. 668-671, IEEE, September1967.
Official URL: http://ieeexplore.ieee.org/document/1138991/
[Smith1983Viewing]
The Viewing Transformation
Alvy Ray Smith
p. 27, Technical Memo #84, June24, 1983.
Free URL: http://alvyray.com/Memos/CG/Pixar/view84.pdf
[Smith1995Pixel]
A Pixel Is Not a Little Square, a Pixel Is Not a Little Square, a Pixel Is Not a Little Square! (And a Voxel Is Not a Little Cube)
Alvy Ray Smith
July17, 1995.
Official URL: http://alvyray.com/Memos/CG/Microsoft/6_pixel.pdf
[Spanier1969]
Monte Carlo Principles and Neutron Transport Problems
Jerome Spanier and Ely Gelbard
Addison-Wesley, 1969.
[Steele90FloatingPoint]
How to Print Floating-Point Numbers Accurately
Guy L. Steele Jr. and Jon L. White
SIGPLAN Notices 25, p. 112-126, ACM, New York, NY, USA, June1990.
Official URL: http://doi.acm.org/10.1145/93548.93559
[Stevens1957Psychophysical]
On the Psychophysical Law
Stanley Smith Stevens
Psychology Review 64:3, p. 153-181, May1957.
Official URL: http://psycnet.apa.org/journals/rev/64/3/153/
[Stokes96sRGB]
A Standard Default Color Space for the Internet - sRGB
Michael Stokes, Matthew Anderson, Srinivasan Chandrasekar, and Ricardo Motta
November5, 1996.
Official URL: http://www.w3.org/Graphics/Color/sRGB
[Stone2011]
Engineering Metrology Toolbox
Jack A. Stone and Jay H. Zimmerman
National Institute of Standards and Technology , December 28 , 2011 .
Free URL: http://emtoolbox.nist.gov/Wavelength/Documentation.asp
[Strang93LinearAlgebra]
Introduction to Linear Algebra
Gilbert Strang
Wellesley-Cambridge Press, 1993.
[Strauss1990Lighting]
A Realistic Lighting Model for Computer Animators
Paul S. Strauss
IEEE Comput. Graph. Appl. 10:6, p. 56-64, IEEE Computer Society Press, Los Alamitos, CA, USA, 1990.
http://dx.doi.org/10.1109/38.62696
[Stroustrup09CPP]
The C++ Programming Language, Special Edition
Bjarne Stroustrup
Addison Wesley, 2009.
[Swoboda2012Procedural]
Advanced Procedural Rendering in DirectX 11
Matt Swoboda
Talk at the Game Developers Conference, 2012.
Free URL: http://directtovideo.wordpress.com/2012/03/15/get-my-slides-from-gdc2012/
[Talbot2005Resample]
Importance Resampling for Global Illumination
Justin F. Talbot, David Cline, and Parris Egbert
in Proceedings of the Eurographics Symposium on Rendering, p. 117-226, Eurographics Association, 2005.
Free URL: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.70.139&rep=rep1&type=pdf
[Tannenbaum1994Polarization]
Polarization and Birefringency Considerations in Rendering
David C. Tannenbaum, Peter Tannenbaum, and Michael J. Wozny
in SIGGRAPH '94: Proceedings of the 21st annual conference on Computer graphics and interactive techniques, p. 221-222, ACM, New York, NY, USA, 1994.
http://doi.acm.org/10.1145/192161.192204
[Toksvig2005Normal]
Mipmapping Normal Maps
Michael Toksvig
Journal of GraphicsTools 10:3, p. 65-71, A K Peters, 2005.
Official URL: http://www.tandfonline.com/doi/pdf/10.1080/2151237X.2005.10129203#.UzIVeK1dVJM
Free URL: ftp://download.nvidia.com/developer/Papers/Mipmapping_Normal_Maps.pdf
[Torrance1967Reflection]
Theory for Off-Specular Reflection From Roughened Surfaces
K. E. Torrance and E. M. Sparrow
Journal of the Optical Society of America 57, p. 1104-1114, September1967.
Official URL: http://www.opticsinfobase.org/abstract.cfm?uri=josa-57-9-1105
[Torrence06Teapot]
Martin Newell's Original Teapot
Ann Torrence
in ACM SIGGRAPH 2006 Teapot, ACM, New York, NY, USA, 2006.
Official URL: http://doi.acm.org/10.1145/1180098.1180128
10.1145/1180098.1180128
[Trowbridge1975Microfacet]
Average Irregularity Representation of a Rough Surface for Ray Reflection
T. S. Trowbridge and K. P. Reitz
Journal of the Optical Society of America 65:5, p. 531-536, OSA, May1975.
Official URL: http://www.opticsinfobase.org/abstract.cfm?URI=josa-65-5-531
[Trowbridge1978Retroreflection]
Retroreflection From Rough Surfaces
T. S. Trowbridge
Journal of the Optical Society of America 68:9, p. 1225-1242, OSA, 1978.
Official URL: http://www.opticsinfobase.org/abstract.cfm?URI=josa-68-9-1225
[Upchurch12Precision]
Tightening the Precision of Perspective Rendering
Paul Upchurch and Mathieu Desbrun
Journal of Graphics Tools 16:2, Taylor and Francis, April2012.
[Veach1995Optimally]
Optimally Combining Sampling Techniques for Monte Carlo Rendering
Eric Veach and Leonidas J. Guibas
in Proceedings of the 22nd annual conference on Computer graphics and interactive techniques, p. 419-428, ACM, New York, NY, USA, 1995.
Official URL: http://doi.acm.org/10.1145/218380.218498
Free URL: http://www-graphics.stanford.edu/papers/combine/
[Veach1997Metropolis]
Metropolis Light Transport
Eric Veach and Leonidas J. Guibas
in SIGGRAPH '97: Proceedings of the 24th annual conference on Computer graphics and interactive techniques, p. 65-76, ACM Press/Addison-Wesley Publishing Co., New York, NY, USA, 1997.
http://doi.acm.org/10.1145/258734.258775
[Veach1998Thesis]
Robust Monte Carlo Methods for Light Transport Simulation
Eric Veach
Adviser-Leonidas J. Guibas, Stanford University, Stanford, CA, USA, 1998.
[Vince10Geometry]
Geometry for Computer Graphics
John A. Vince
Springer, 2010.
[Wald2001Coherent]
Interactive Rendering With Coherent Ray-Tracing
Ingo Wald, Carsten Benthin, Markus Wagner, and Philipp Slusallek
in Computer Graphics Forum, (Proceedings of EUROGRAPHICS), Eurographics, 2001.
Free URL: http://www.sci.utah.edu/~wald/Publications/2001/CRT/CRT.pdf
[Walter2007Microfacet]
Microfacet Models for Refraction Through Rough Surfaces
Bruce Walter, Stephen R. Marschner, Hongsong Li, and Kenneth E. Torrance
in Proceedings of the 18th Eurographics Conference on Rendering Techniques, p. 195-206, Eurographics Association, Aire-la-Ville, Switzerland, 2007.
Official URL: http://dx.doi.org/10.2312/EGWR/EGSR07/195-206
Free URL: https://www.cs.cornell.edu/~srm/publications/EGSR07-btdf.pdf
10.2312/EGWR/EGSR07/195-206
[Ward1992Anisotropic]
Measuring and Modeling Anisotropic Reflection
Gregory J. Ward
SIGGRAPH Comput. Graph. 26:2, p. 265-272, ACM, New York, NY, USA, 1992.
http://doi.acm.org/10.1145/142920.134078
[Ward91Pixels]
Real Pixels
Greg Ward
in Graphics Gems II, James Arvo (ed.), ch. 5, p. 80-85, Academic Press / Morgan Kaufmann, 1991.
[Weidlich2008Crystals]
Realistic Rendering of Birefringency in Uniaxial Crystals
Andrea Weidlich and Alexander Wilkie
ACM Trans. Graph. 27:1, p. 1-12, ACM, New York, NY, USA, 2008.
http://doi.acm.org/10.1145/1330511.1330517
[Wenzel2007]
Real-Time Atmospheric Effects in Games Revisited
C. Wenzel
Talk at GDC 2007, March 5, 2007.
Free URL: http://www.crytek.com/download/GDC2007_RealtimeAtmoFxInGamesRev.ppt
[Westin1992Reflectance]
Predicting Reflectance Functions From Complex Surfaces
Stephen H. Westin, James R. Arvo, and Kenneth E. Torrance
SIGGRAPH Comput. Graph. 26:2, p. 255-264, ACM, New York, NY, USA, 1992.
http://doi.acm.org/10.1145/142920.134075
[Weyrich2006Skin]
Analysis of Human Faces Using a Measurement-Based Skin Reflectance Model
Tim Weyrich, Wojciech Matusik, Hanspeter Pfister, Bernd Bickel, Craig Donner, Chien Tu, Janet McAndless, Jinho Lee, Addy Ngan, Henrik Wann Jensen, and Markus Gross
ACM Trans. Graph. 25:3, p. 1013-1024, ACM, New York, NY, USA, 2006.
http://doi.acm.org/10.1145/1141911.1141987
[Whitted1980Illumination]
An Improved Illumination Model for Shaded Display
Turner Whitted
Commun. ACM 23:6, p. 343-349, ACM, New York, NY, USA, 1980.
http://doi.acm.org/10.1145/358876.358882
[Williamson1983Light]
Light and Color in Nature and Art
Samuel J. Williamson and Herman Z. Cummins
p. 488, Wiley, 1983.
[Wolff1990Polarization]
Ray Tracing With Polarization Parameters
Lawrence B. Wolff and David J. Kurlander
IEEE Comput. Graph. Appl. 10:6, p. 44-55, IEEE Computer Society Press, Los Alamitos, CA, USA, 1990.
http://dx.doi.org/10.1109/38.62695
[Zibordi1989Sky]
Geometrical and Spectral Distribution of Sky Radiance - Comparison Between Simulations and Field Measurements
Zibordi
Remote Sensing of Environment 27, p. 343-358, March1989.
[pmodwrc]
Solar Constant: Construction of a Composite Total Solar Irradiance Time Series From 1978 to Present
World Radiation Center
2008.
Official URL: http://www.pmodwrc.ch/pmod.php?topic=tsi/composite/SolarConstant
Reader's Guide
How To
Links (References)
About The Graphics Codex
New in this Version
Bibliography
Preface
Prerequisites — Educational Goals — Topics Covered — Structure — Projects and Code — Primary Sources — Feedback
Introduction
Images and Light — Physically Based Rendering — The Rendering EquationRadiometry Photometry light ray primary ray Rendering Equation
C++
An Example — Header and Source Files — Memory Model — Types — Plain Old Data — Pointer Types — Stack and Heap Allocation — References — const References — Reference-Counted Pointers — Copying and Assignment — Pre- and Post-Increment — Conclusion: The C++ Programmer Mindsetheader source translation units linker variable value address type pointer dereference dangling pointers memory leak reference reference-counted pointer shared pointer
Surface Geometry
What is a Surface? — The Speeds of Light — Surfaces are Interfaces — Modeling a 1D Surface in 2D Space — A Surface is a Set of Points — Implicit Form — Explicit Form — Triangle Meshes — A Triangle — Triangle List — Indexed Triangle Listobject implicit explicit homogeneous optical interface boundary oriented implicit explicit simplex front mesh triangle list tetrahedron indexed triangle list vertex array index array
A Model of Light
Digital Images are Measurements — Rays of Light — Transport Paths — Vectors — Unit Vectors — Geometric Rays — The Light Field — Light is Conserved Along a Ray — Assumptions and Simplificationslight field crepuscular rays ray line segment line segment path emitter luminaire light source vector magnitude length unit vector normalizing unit sphere light field plenoptic function 4D light field light slab Lumigraph time phase Polarization frequencies
The Rendering Equation
Radiometric Units — Photon Energy — Power — Irradiance and Radiosity — The Measure of a Set — Radiance — Measurements in Different Frames — Lambert's Projected Area — Vector Dot Product — The Rendering Equation — Rendering is Very Hardradiometry energy photons power flux Irradiance radiosity measure angle solid angle steradians Radiance Lambert's cosine law dot product inner product integral equation
Version Control Basics
Systems — Advantages — Repository Model — An Example — Concurrent Changes — Typical Workflow — Starting a Project — Pull into the Workspace — Merge Conflicts — Adding and Removing Files — Push to the Remote Repository — Leveraging Versions — Checking the Log — Inspecting Old Versions — Workspace Undo — Local Repository Undo — Remote Repository Undo — Best PracticesSubversion git Perforce server client bridges remote repository workspace revision history distributed version control systems local repository local snapshot pulls commits pushes conflict resolved log message log git perforce p4 svn subversion mercurial hg cvs rcs source control source management revision control
A Camera Model
Images — Images are Everywhere — An Aperture Selects an Image — A 16ᵗʰ Century Mechanical Renderer — A Modern Computational Renderer — Primary Rays from a Pinhole Camera — Dynamic Range — Gamma Encoding — Bloom — Desaturationpinhole aperture virtual image real image data driven ray casting surface element (surfel) direct illumination dynamic range tone mapping gamma encoding Bloom
Ray Casting
Ray Casting Algorithm — Ray-Sphere Intersection — Ray-Plane Intersection — Ray-Triangle Intersection — Unit Triangle — Barycentric Coordinates — Arbitrary Triangle — Vector Cross Product — Triangle Mesh — Some Performance Considerations — Visualization for Debugging — Texture Coordinates — Stepping Into One Pixelray casting surface element surfel unit triangle barycentric coordinate barycenter signed area cross product cross product procedural early out spatial data structure Visualization texture coordinate texture map ray trace
Direct Illumination
Radiance is Conserved Along a Ray — Direct Illumination — Scattered Radiance — Biradiance — Implementing Point Lights — Shadows — The Visibility Function — Ambient Illuminationdirect illumination ambient term direct illumination point light biradiance shadow visibility function ambient environment mapping irradiance mapping
Materials
Probability Density — The BSDF — Lambert's Law — Scattering Functions — Common Terms — Mirror Reflection — Implementing Impulses — Transmission and Refraction — Microfacets — Subsurface Scattering — Lambertian Reflection — The Fresnel Effect — Partial Coverage — Compositing — Alpha Cutout — Perceived Colorbidirectional scattering distribution function material scattering function bump partial coverage probability mass probability density differential probability probability mass bidirectional scattering distribution function reflective bidirectional reflectance distribution function transmission non-negative energy conserving reciprocal passive Lambert's Law scattering distribution photon distribution impulse transmits refraction microfacets diffuse half vector Lambertian reflectivity normal incidence partial coverage over composite brdf btdf shading
Rendering Algorithms
The Transport Graph — Path Notation — Node Types — Operators — Notable Phenomena — Direct and Ambient Illumination — Whitted Ray Tracing — Path Tracing — Bidirectional Path Tracing — Photon Mapping — Radiositytransport graph Path notation uminaire pecular iffuse ye Caustics Mirror reflections perfect refraction Diffuse interreflection color bleeding shadow Highlights ambient Whitted ray tracing backwards ray tracing ray tracing path tracing Bidirectional path tracing photon mapping consistent biased radiosity algorithm form factor metropolis radiosity
Numerical Calculus
Definition of a Derivative — Numerical Differentiation — Definition of an Integral — Analytic Integration — Numerical Integration — A Tale of Two Cities — Las Vegas — Monte Carlo — Monte Carlo Integration — An Energy Examplederivative differentiable analytically power rule antiderivative symbolic analytic Numerical (definite) integration samples randomized algorithms nondeterministic stochastic deterministic algorithms Las Vegas Monte Carlo Monte Carlo (definite) Integral estimator probability density function converged
Path Tracing
A Simple Implementation — Algorithmic Complexity — The Transport Graph — Elements of Path Tracing — Applying Monte Carlo Integration — The Camera Integrals — Distributed Sampling — The Transport Integral — Terminal Cases — Importance SamplingReverse, recursive ray tracing Distributed sampling Markov chain Monte Carlo Importance sampling spatial data structures SIMD SPMD stream processing Fixed-function hardware distributed sampling Russian roulette shadow rays material importance sampling bidirectional scattering distribution function (BSDF) importance sampling direct resampling
Ray Marching
Intersection Algorithms — Marching — Distance Estimators — Sphere Tracing — Some Distance Estimators — Sphere — Plane — Box — Rounded Box — Torus — Wheel — Cylinder — Computing Normals — A Simple GLSL Ray Caster — C++ Shader Launch — GLSL Ray Setup — GLSL Intersection — Operations on Distance Estimators — Some Useful Operators — Union — Intersection — Subtraction — Repetition — Transformation — Blending — Increasing Performance — Over-Relaxation — Bounding Spheres — Reintroducing Analytic Roots — Other Optimization Strategies — Some Online Examples in GLSL — Educational — Aspirational — Further Readingimplicit surface Analytic ray-surface intersection explicit equation Ray marching Rasterization depth buffer signed distance estimators isosurface level set sphere tracing gradient surface normal point-based graphics GPU implicit signed distance
Parallel Architectures
SIMD — Coherence — Memory Coalescing — Cores — Thread Pools and Megakernels — Occupancy — Synchronization — Pipelines — Physics Revisited — Super-Linear Speedups — Intra-core Utilization — Memory — Physics Revisited — Structures and ArraysSIMD SIMT lane masked coherent divergent coalesce virtual cores physical cores Stream Processor CUDA Core thread pooling Megakernel occupancy concurrent strict parallel race condition deadlock atomic operations mutexes spinlocks semaphores lockless datastructures barrier pipelining bubble array of structures (AOS) structure of arrays (SOA) GPU CPU SIMT AVX SSE warp CUDA
The Eye
Photoreceptors — Photoreceptor Response — Photopic Vision — Scotopic Visioncones rods punctum caecum
3D Model File Formats
A* Search
ASCII
Character Table
Diacritics and Ligatures
Greek Letters
Math Symbol Table
αAbsorption Coefficient
Adams, Ansel
Tetons and the Snake River
Angle
Arg Max
Array
Fast Remove
Filter
Shuffle
αAttenuation Coefficient
ψAzimuth Angle Measure
Bacon, Francis
Study for a Self-Portrait-Triptych
Three Studies of Lucian Freud
Ball
-Ray Intersection
Surface Area
Volume
to Ball Distance
Barycentric Coordinates
Bayes' Rule
Beer-Lambert Law
βBiradiance
Blinn Microfacet BSDF
Blinn-Phong Microfacet
DXDistribution
GXGeometry Term
Botticelli, Sandro
Nascita di Venere (The Birth of Venus)
Bouguereau, William-Adolphe
La Naissance de Vénus (The Birth of Venus)
C/C++
Function Pointer
Integers
Lambda
Method Pointer
Syntax Example
printf Specification
std::function
std::shared_ptr
Cabanel, Alexandre
La Naissance de Vénus (The Birth of Venus)
Church, Frederic Edwin
Heart of the Andes
Niagara
clamp(⋅)Clamp
Compressed Texture Formats
Conditional Expression
Cone
Random Direction Inside
Convolution
cosCosine
Hardy's Approximation
coshHyperbolic
Taylor Polynomial
Cosine-Weighted Hemisphere
Crepuscular Ray Image
×Cross Product
Cross-Correlation
Cylinder
Surface Area
Volume
det(A)Determinant
det(A)2×2 Matrix
det(A)3×3 Matrix
det(A)4×4 Matrix
Differential Solid Angle
Directions
Distance
Euclidean
Line-Line
Manhattan
Point-Line
Point-Plane
Point-Point
Sphere-Sphere
Table of Useful Lengths
Dot Product
Duchamp, Marcel
Nu descendant un escalier no2
Dürer, Albrecht
Man Drawing a Lute (annotated)
Man Drawing a Lute
Perspective Nude
Perspective Woodcut
Electromagnetic Spectrum
Euler
χCharacteristic
eConstant
Formula
Expected Value
E(X)of a Random Variable
of a Series
κExtinction Coefficient
File Format
3D Models
Raster Images
Floating Point Formats
Fog, Simple Models
Frame Rate Table
Frequency
Display Refresh
fof Light
νof Light, Spatial
F(⋅)Fresnel Coefficient
F0F0 for Selected Materials
FS(⋅)Schlick's Approximation
F0at Normal Incidence
Fc(⋅)for a Conductor
Fd(⋅)for a Dielectric
GGX/TR/GTR2
GGeometry Term
DMicrofacet Distribution
GLSL
Functions
Matrix Notation
DGTR1/Berry Microfacet Distribution
Gamma Compression
DGeneralized Trowbridge-Reitz (GTR)
Geometric Series
Git
Quick Reference
ϕGolden Ratio
Greek Alphabet
HLSL Matrix Notation
HTML
CSS Box Model
CSS3 Custom Font
CSS3 Selectors
Diacritics and Ligatures
Greek Letter Table
HTML5 Example
Math Symbol Table
Half Vector
||⋅||Hausdorff Measure
Heap Sort
ℋ()Heaviside Step Function
S+2Hemisphere
Cosine-weighted
ρ(ωo)Hemispherical-Directional Reflectance
Holbein, Hans
The Ambassadors
Hue-Saturation-Value to/from sRGB
Hull Speed
Human Retina
Photoreceptor Density
Spectral Response
Hyperbolic
coshCosine
θInclination Angle Measure
Incoming
Li(⋅)Light Field
Light Vector
Reflection Vector
Refraction Vector
Increment Mod 3
Index of Refraction
Complex
ηReal
for Selected Materials
Insertion Sort
EIrradiance
JavaScript
Operators
Types
LaTeX
Greek Letter Table
Math Symbol Table
Size Command Table
Space Command Table
includegraphics
Lambertian Surface
Latin Square Sampling
Law of Cosines
L(⋅)Light Field
Li(⋅)Incoming
Lo(⋅)Outgoing
Line
to Line Distance
to Point Distance and Closest Point
lerp(⋅)Linear Interpolation
Luminance
Magritte, René
Empire of Lights
Treachery of Images
Matrix
det(A)2×2 Determinant
A-12×2 Inverse
det(A)3×3 Determinant
A-13×3 Inverse
det(A)4×4 Determinant
:Frobenius Inner Product
Hadamard Product
Multiplication
RRotation (Roll, Yaw, Pitch)
RRotation from Axis and Angle
RRotation from Unit Quaternion
SScale
XSkew-Symmetric
TTranslation
det(A)n×n Determinant
Pzf = -∞ Perspective Projection
Pzf > -∞ Perspective Projection
Mean
Arithmetic
E(X)Expected Value
Geometric
||⋅||Measure (Hausdorff)
Merge Sort
Metric Prefixes
DXMicrofacet Distribution
crMicrofacet Reflection Angle Cosine
αXMicrofacet Roughness
Microfacet Scattering Function
Microfacet Smoothness
mirror(⋅)Mirror Reflection Operator
Monte Carlo Integration
S(⋅)Normalize a Vector
Normalized Fixed-Point
OOrigin
Outgoing
Lo(⋅)Light Field
Light Vector
Refraction Vector
Specular Reflection Vector
PICO-8
Controllers
Palette
PPerspective Projection Matrix
PInfinite
Inverting
Phong-like Scattering Functions
1973 Original
1977 Blinn Half-vector version
1986 Normalized Phong
2008 Normalized Blinn-Phong
Photon
QEnergy
fFrequency
νSpatial Frequency
λWavelength
Photoreceptor
Density, Human
Spectral Response, Human
Picasso, Pablo
Guernica
Les Damoiselles d'Avignon
hPlanck Constant
L(⋅)Plenoptic Function
Point
to Line Distance
to Plane Distance
to Point Distance
Point Lights
ΦPower
Pythagorean Theorem
Python
Lambda
Quadratic Formula
Quaternion, Unit
Basis
slerp(⋅)Interpolation
Inverse
Multiplication
from Axis and Angle
to Matrix
Quick Sort
RGB to Grayscale
RGB to/from sRGB
LRadiance
L(⋅)Radiance Function
MRadiant Emittance
MRadiant Exitance
ΦRadiant Flux
IRadiant Intensity
Radiometric Unit Table
Depicted
BRadiosity
Random Number Generator
Box-Muller Gaussian
Integer
clamp(⋅)Range Clamp
Raphael (Raffaello Sanzio da Urbino)
School of Athens
Ray
-Plane Intersection
-Sphere Intersection
-Triangle Intersection
Reciprocity
Reflectance (Albedo)
Reflection
crAngle, Microfacet Cosine of
mirror(⋅)Operator
Vector (Incoming)
Vector (Outgoing)
Refraction
ctAngle, Microfacet Cosine of
Index of (Complex)
ηIndex of (Real)
refract(⋅)Operator
Vector (Incoming)
Vector (Outgoing)
Rendering Equation, The
Area Domain (Kajiya)
Sphere Domain (Immel et al.)
Rodrigues' Formula
Scalar Triple Product
Scattering Function (BSDF)
Scattering Variables
FS(⋅)Schlick's Fresnel Approximation
Screen Resolution Table
Screenshot Keys
Shadow Map
Shader Pseudocode
Shallow Water Equation
sinSine
Taylor Polynomial
slerp(⋅)Slerp
Snell's Law
Solid Angle
Differential
Measure of a Lat-Long Patch
Measure of a Triangle
Sort
Heap
Insertion
Merge
Quick
Spectrum
Electromagnetic
Visible Light
c0Speed of Light (in Vacuum)
Sphere
-Ray Intersection
3D Random Direction
Surface Area
Unit
Volume Inside
to Sphere Distance
Spherical Coordinates
Right-handed with y=up
Right-handed with z=up
Subversion
Quick Reference
Sun
Spectrum
Table of Useful Speeds
Tetrahedron
Surface Area
Volume
Toksvig Normal Distribution
Transformation Matrix
RRotation (Roll, Yaw, Pitch)
RRotation from Axis and Angle
RRotation from Unit Quaternion
SScale
XSkew-Symmetric
TTranslation
Triangle
-Ray Intersection
Area
Solid Angle
Trigonometric Identities
Type Notation
Semantic
Structural
Unicode
Diacritics and Ligatures
Greek Letter Table
Math Symbol Table
Unit Sphere
Unproject from depth
Variance
Var,σof a Random Variable
Vector
×Cross Product
Dot Product
||⋅||Magnitude
Versor (Unit Quaternion)
Basis
slerp(⋅)Interpolation
Inverse
Multiplication
from Axis and Angle
from Rotation Matrix
to Matrix
Web Servers, Simple
XML
Escape Code Table
Greek Letter Table
Math Symbol Table
da Vinci, Leonardo
Mona Lisa
The Last Supper
πpi
printf Specification
smootherstep
smoothstep
The Graphics Codex provided by the NVIDIA Deep Learning Institute

Index


Smaller

Larger

Hide